home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / superopt.5 / superopt / superopt-2.5 / superopt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-02  |  89.1 KB  |  3,081 lines
  1. /* Superoptimizer.  Finds the shortest instruction sequences for an arbitrary
  2.    function y=f(x) where x is a vector of integer and y is a is a single
  3.    integers.  The algorithm is based on exhaustive search with backtracking
  4.    and iterative deepening.
  5.  
  6.    Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
  7.  
  8.    This program is free software; you can redistribute it and/or modify it
  9.    under the terms of the GNU General Public License as published by the
  10.    Free Software Foundation; either version 2, or (at your option) any
  11.    later version.
  12.  
  13.    This program is distributed in the hope that it will be useful, but
  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.    General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License along
  19.    with this program; see the file COPYING.  If not, write to the Free
  20.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include <stdio.h>
  23. #include <string.h>
  24.  
  25. #include "superopt.h"
  26.  
  27. word random_word(void);
  28.  
  29. #include "run_program.def"
  30. #include "version.h"
  31.  
  32. int goal_function_arity;
  33. enum goal_func goal_function;
  34. word (*eval_goal_function) (const word *);
  35.  
  36. int flag_output_assembly = 0;
  37. int flag_use_carry = 1;
  38. int flag_shifts = 0;
  39. int flag_extracts = 0;
  40. int flag_nl = 0;
  41.  
  42. /* Counts the number of solutions found.  Flags to top loop that it should
  43.    not go deeper.  */
  44. int success;
  45.  
  46. #ifdef TIMING
  47. #ifndef USG
  48. #include <sys/time.h>
  49. #include <sys/resource.h>
  50.  
  51. unsigned long
  52. cputime ()
  53. {
  54.     struct rusage rus;
  55.  
  56.     getrusage (0, &rus);
  57.     return rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
  58. }
  59. #else
  60. #include <time.h>
  61.  
  62. unsigned long
  63. cputime ()
  64. {
  65.   return clock () / 1000;
  66. }
  67. #endif
  68. int timings[100];
  69. #endif
  70.  
  71. #ifdef STATISTICS
  72. unsigned int heuristic_reject_count = 0;
  73. unsigned int heuristic_accept_count = 0;
  74. #endif
  75.  
  76. char *insn_name[] =
  77. {
  78. #undef    DEF_INSN
  79. #define DEF_INSN(SYM,CLASS,NAME) NAME,
  80. #include "insn.def"
  81. };
  82.  
  83. char insn_class[] =
  84. {
  85. #undef    DEF_INSN
  86. #define DEF_INSN(SYM,CLASS,NAME) CLASS,
  87. #include "insn.def"
  88. };
  89.  
  90. /* Initialize the "immediate" values in the top registers.  */
  91. void
  92. init_immediates(word *values)
  93. {
  94.   int i;
  95.   for (i = -1; i < BITS_PER_WORD; i++)
  96.     values[0x20 + i] = i;
  97.  
  98.   values[0x20 - 2] = VALUE_MIN_SIGNED;
  99.   values[0x20 - 3] = VALUE_MAX_SIGNED;
  100.   values[0x20 - 4] = 0xFFFF;
  101.   values[0x20 - 5] = 0xFF;
  102. }
  103.  
  104. #if defined (__svr4) || defined (__hpux) || defined (_SVR4_SOURCE)
  105. #define random mrand48
  106. #endif
  107.  
  108. void
  109. init_random_word (void)
  110. {
  111. #if defined (__svr4) || defined (__hpux) || defined (_SVR4_SOURCE)
  112.   static unsigned short state1[3] = { 0xeb3d, 0x799f, 0xb11e };
  113.   srand48 (state1);
  114. #else
  115.   static char state1[128] =
  116.     {
  117.       0, 0, 0, 3,
  118.       0x9a,0x31,0x90,0x39, 0x32,0xd9,0xc0,0x24, 0x9b,0x66,0x31,0x82, 0x5d,0xa1,0xf3,0x42,
  119.       0x74,0x49,0xe5,0x6b, 0xbe,0xb1,0xdb,0xb0, 0xab,0x5c,0x59,0x18, 0x94,0x65,0x54,0xfd,
  120.       0x8c,0x2e,0x68,0x0f, 0xeb,0x3d,0x79,0x9f, 0xb1,0x1e,0xe0,0xb7, 0x2d,0x43,0x6b,0x86,
  121.       0xda,0x67,0x2e,0x2a, 0x15,0x88,0xca,0x88, 0xe3,0x69,0x73,0x5d, 0x90,0x4f,0x35,0xf7,
  122.       0xd7,0x15,0x8f,0xd6, 0x6f,0xa6,0xf0,0x51, 0x61,0x6e,0x6b,0x96, 0xac,0x94,0xef,0xdc,
  123.       0xde,0x3b,0x81,0xe0, 0xdf,0x0a,0x6f,0xb5, 0xf1,0x03,0xbc,0x02, 0x48,0xf3,0x40,0xfb,
  124.       0x36,0x41,0x3f,0x93, 0xc6,0x22,0xc2,0x98, 0xf5,0xa4,0x2a,0xb8, 0x8a,0x88,0xd7,0x7b,
  125.       0xf5,0xad,0x9d,0x0e, 0x89,0x99,0x22,0x0b, 0x27,0xfb,0x47,0xb9
  126.     };
  127.   unsigned seed;
  128.   int n;
  129.  
  130.   seed = 1;
  131.   n = 128;
  132.   initstate (seed, (char *) state1, n);
  133.   setstate (state1);
  134. #endif
  135. }
  136.  
  137. #define RANDOM(res,rbits) \
  138.   do {                                \
  139.     if (valid_randbits < rbits)                    \
  140.       {                                \
  141.     ran = random ();                    \
  142.     valid_randbits = 31;                    \
  143.       }                                \
  144.     res = ran & (((word) 1 << rbits) - 1);            \
  145.     ran >>= rbits;                        \
  146.     valid_randbits -= rbits;                    \
  147.   } while (0)
  148.  
  149. word
  150. random_word (void)
  151. {
  152.   word x;
  153.   unsigned int ran, n_bits;
  154.   int valid_randbits = 0;
  155.   int tmp, i;
  156.  
  157.   /* Return small values with higher probability.  */
  158.   RANDOM (tmp, 9);
  159.   if (tmp <= 60)
  160.     return tmp + 4;
  161.  
  162.   /* Start off with only ones or only zeros, with equal probability.  */
  163.   RANDOM (tmp, 1);
  164.   x = 0;
  165.   if (tmp)
  166.     x = ~x;
  167.  
  168.   /* Now generate random strings of ones and zeros.  */
  169.   n_bits = 0;
  170.   for (i = 8 * sizeof (word); i >= 0; i -= n_bits)
  171.     {
  172.       RANDOM (tmp, 3);
  173.       n_bits = tmp + 1;
  174.       x <<= n_bits;
  175.       RANDOM (tmp, 1);
  176.       if (tmp)
  177.     x |= ((word) 1 << n_bits) - 1;
  178.     }
  179.  
  180.   return x;
  181. }
  182.  
  183. void *malloc (), *realloc ();
  184.  
  185. char *
  186. xrealloc (ptr, size)
  187.      char *ptr;
  188.      unsigned size;
  189. {
  190.   char *result = (char *) realloc (ptr, size);
  191.   if (!result)
  192.     abort ();
  193.   return result;
  194. }
  195.  
  196. char *
  197. xmalloc (size)
  198.      unsigned size;
  199. {
  200.   register char *val = (char *) malloc (size);
  201.  
  202.   if (val == 0)
  203.     abort ();
  204.   return val;
  205. }
  206.  
  207. #if HAS_NULLIFICATION
  208. #define SYNTH(sequence, n_insns, values, n_values, goal_value, \
  209.           allowed_cost, cy, prune_flags, nullify_flag)        \
  210.   do {                                    \
  211.     if (allowed_cost == 1)                        \
  212.       synth_last(sequence, n_insns, values, n_values, goal_value,    \
  213.          allowed_cost, cy, prune_flags, nullify_flag);        \
  214.     else                                \
  215.       synth(sequence, n_insns, values, n_values, goal_value,        \
  216.         allowed_cost, cy, prune_flags, nullify_flag);        \
  217.   } while (0)
  218. #else
  219. #define SYNTH(sequence, n_insns, values, n_values, goal_value, \
  220.           allowed_cost, cy, prune_flags, nullify_flag)        \
  221.   do {                                    \
  222.     if (allowed_cost == 1)                        \
  223.       synth_last(sequence, n_insns, values, n_values, goal_value,    \
  224.          allowed_cost, cy, prune_flags);            \
  225.     else                                \
  226.       synth(sequence, n_insns, values, n_values, goal_value,        \
  227.         allowed_cost, cy, prune_flags);                \
  228.   } while (0)
  229. #endif
  230.  
  231. /* Save the last generated instruction and recursively call `synth', if we
  232.    are not at a leaf node.  Otherwise test the computed value and
  233.    back-track.  This function is extremely critical for the performance!
  234.  
  235.    OPCODE is the opcode of the insn that was just generated.
  236.  
  237.    D is the destination register.
  238.  
  239.    S1 is the left source register or immediate reference.  It is an
  240.    immediate reference if IMMEDIATE_P(S1) is true.
  241.  
  242.    S2 is the right source register or immediate reference.  It is an
  243.    immediate reference if IMMEDIATE_P(S2) is true.
  244.  
  245.    V is the computed result from "rD = rS1 OPCODE rS2".
  246.  
  247.    COST is the cost of OPCODE with the the actual operands.
  248.  
  249.    SEQUENCE is the insn sequence so far, excluding the just generated insn.
  250.  
  251.    N_INSNS is the number of insns in SEQUENCE.
  252.  
  253.    VALUES contains the values in register 0..N_VALUES.
  254.  
  255.    N_VALUES is the number of registers that have been assigned values by
  256.    the insns so far.
  257.  
  258.    GOAL_VALUE is the value we aim at, when the sequence is ready.
  259.  
  260.    ALLOWED_COST is the maximum allowed cost of the remaining sequence.
  261.  
  262.    CY is the carry flag.  It is negative if it has an undefined value (this
  263.    for pruning the search tree), and otherwise takes the values 0 or 1
  264.    according to the conventions of the current target.
  265.  
  266.    PRUNE_HINT contains flags to assist pruning of the search tree.  */
  267.  
  268. static void
  269. recurse(opcode_t opcode,
  270.     int d,
  271.     int s1,
  272.     int s2,
  273.     word v,
  274.     int cost,
  275.     insn_t *sequence,
  276.     int n_insns,
  277.     word *values,
  278.     int n_values,
  279.     const word goal_value,
  280.     int allowed_cost,
  281.     int cy,
  282.     int prune_flags
  283. #if HAS_NULLIFICATION
  284.     ,int nullify_flag
  285. #endif
  286.     )
  287. {
  288.   insn_t insn;
  289.  
  290.   /* Update the remaining allowed cost with the cost of the last
  291.      instruction.  */
  292.   allowed_cost -= cost;
  293.  
  294.   if (allowed_cost > 0)
  295.     {
  296.       /* ALLOWED_COST is still positive, meaning we can generate more
  297.      instructions.  */
  298.       word old_d;
  299.  
  300. #if HAS_NULLIFICATION
  301.       /* If we we have one more instruction, and it will be nullified for the
  302.      used arguments, ensure already now that we have the goal value
  303.      somewhere.  Kludge for speed.  */
  304.       if (allowed_cost == 1 && nullify_flag)
  305.     {
  306.       int i;
  307.       if (v == goal_value)
  308.         goto found_goal_value;
  309.       for (i = 0; i < n_values; i++)
  310.         if (values[i] == goal_value)
  311.           goto found_goal_value;
  312.       return;
  313.     found_goal_value:;
  314.     }
  315. #endif
  316.  
  317.       /* Remember old value of dest. reg.  Move to CRECURSE_2OP???  */
  318.       old_d = values[d];
  319.       values[d] = v;
  320.  
  321. #if __GNUC__
  322.       sequence[n_insns] = (insn_t) {opcode, s1, s2, d};
  323. #else
  324.       insn.opcode = opcode;
  325.       insn.s1 = s1;
  326.       insn.s2 = s2;
  327.       insn.d = d;
  328.       sequence[n_insns] = insn;
  329. #endif
  330.  
  331.       SYNTH(sequence, n_insns + 1, values, n_values, goal_value,
  332.          allowed_cost, cy, prune_flags, nullify_flag);
  333.  
  334.       /* Restore value of dest. reg.  Move to CRECURSE_2OP???  */
  335.       values[d] = old_d;
  336.     }
  337.   else if (goal_value == v)
  338.     {
  339.       /* We are at a leaf node and got the right answer for the
  340.      random value operands.  However, we probably have an
  341.      incorrect sequence.  Call test_sequence to find out.  */
  342.  
  343. #if __GNUC__
  344.       sequence[n_insns] = (insn_t) {opcode, s1, s2, d};
  345. #else
  346.       insn.opcode = opcode;
  347.       insn.s1 = s1;
  348.       insn.s2 = s2;
  349.       insn.d = d;
  350.       sequence[n_insns] = insn;
  351. #endif
  352.       test_sequence(sequence, n_insns + 1);
  353.  
  354. #ifdef STATISTICS
  355.       heuristic_accept_count++;
  356. #endif
  357.  
  358.     }
  359. #ifdef STATISTICS
  360.   else
  361.     heuristic_reject_count++;
  362. #endif
  363. }
  364.  
  365. static inline void
  366. recurse_last(opcode_t opcode,
  367.          int d,
  368.          int s1,
  369.          int s2,
  370.          word v,
  371.          insn_t *sequence,
  372.          int n_insns,
  373.          const word goal_value)
  374. {
  375.   insn_t insn;
  376.  
  377.   if (goal_value == v)
  378.     {
  379.       /* We are at a leaf node and got the right answer for the
  380.      random value operands.  However, we probably have an
  381.      incorrect sequence.  Call test_sequence to find out.  */
  382.  
  383. #if __GNUC__
  384.       sequence[n_insns] = (insn_t) {opcode, s1, s2, d};
  385. #else
  386.       insn.opcode = opcode;
  387.       insn.s1 = s1;
  388.       insn.s2 = s2;
  389.       insn.d = d;
  390.       sequence[n_insns] = insn;
  391. #endif
  392.       test_sequence(sequence, n_insns + 1);
  393.  
  394. #ifdef STATISTICS
  395.       heuristic_accept_count++;
  396. #endif
  397.     }
  398. #ifdef STATISTICS
  399.   else
  400.     heuristic_reject_count++;
  401. #endif
  402. }
  403.  
  404. #define NAME(op) operand_names[op]
  405. static char *operand_names[256]=
  406. {
  407. #if SPARC
  408.   "%i0", "%i1", "%i2", "%i3", "%i4", "%i5", "%i6", "%i7",
  409. #elif POWER
  410.   "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
  411. #elif M88000
  412.   "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
  413. #elif AM29K
  414.   "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", "lr8", "lr9",
  415. #elif M68000
  416.   "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
  417. #elif I386
  418.   "%eax", "%edx", "%ecx", "%ebx", "%esi", "%edi", "%noooo!", "%crash!!!",
  419. #elif PYR
  420.   "pr0", "pr1", "pr2", "pr3", "pr4", "pr5", "pr6", "pr7",
  421. #elif ALPHA
  422.   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  423. #elif HPPA
  424.   "%r26", "%r25", "%r24", "%r23", "%r22", "%r21", "%r20", "%r19",
  425. #elif SH
  426.   "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",
  427. #elif I960
  428.   "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
  429. #else
  430. #error no register names for this CPU
  431. #endif
  432.   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  433. #if SPARC
  434.   "???%hi(0x7fffffff)","%hi(0x80000000)","-1","%g0","1","2","3","4","5","6",
  435.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  436.   "20","21","22","23","24","25","26","27","28","29","30","31",
  437. #elif POWER
  438.   "0x7fff","0x8000","-1","0","1","2","3","4","5","6",
  439.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  440.   "20","21","22","23","24","25","26","27","28","29","30","31",
  441. #elif M88000
  442.   "hi16(0x7fffffff)","hi16(0x80000000)","-1","r0","1","2","3","4","5","6",
  443.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  444.   "20","21","22","23","24","25","26","27","28","29","30","31",
  445. #elif AM29K
  446.   "0x7fff","0x8000","-1","0","1","2","3","4","5","6",
  447.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  448.   "20","21","22","23","24","25","26","27","28","29","30","31",
  449. #elif M68000 || SH
  450.   "#0x7fffffff","#0x80000000","#-1","#0","#1","#2","#3","#4","#5","#6",
  451.   "#7","#8","#9","#10","#11","#12","#13","#14","#15","#16","#17","#18","#19",
  452.   "#20","#21","#22","#23","#24","#25","#26","#27","#28","#29","#30","#31",
  453. #elif I386 || PYR
  454.   "$0x7fffffff","$0x80000000","$-1","$0","$1","$2","$3","$4","$5","$6",
  455.   "$7","$8","$9","$10","$11","$12","$13","$14","$15","$16","$17","$18","$19",
  456.   "$20","$21","$22","$23","$24","$25","$26","$27","$28","$29","$30","$31",
  457. #elif ALPHA
  458.   "0x7fff","0x8000","-1","$31","1","2","3","4","5","6",
  459.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  460.   "20","21","22","23","24","25","26","27","28","29","30","31",
  461.   "32","33","34","35","36","37","38","39","40","41","42","43",
  462.   "44","45","46","47","48","49","50","51","52","53","54","55",
  463.   "56","57","58","59","60","61","62","63",
  464. #elif HPPA
  465.   "0x7fff","0x8000","-1","%r0","1","2","3","4","5","6",
  466.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  467.   "20","21","22","23","24","25","26","27","28","29","30","31",
  468. #elif I960
  469.   "0x7fffffff","0x80000000","-1","0","1","2","3","4","5","6",
  470.   "7","8","9","10","11","12","13","14","15","16","17","18","19",
  471.   "20","21","22","23","24","25","26","27","28","29","30","31",
  472. #else
  473. #error no constant syntax for this CPU
  474. #endif
  475. };
  476.  
  477. /* Output INSN in assembly mnemonic format on stdout.  */
  478.  
  479. void
  480. output_assembly(insn_t insn)
  481. {
  482.   int d, s1, s2;
  483.  
  484.   d = insn.d;
  485.   s1 = insn.s1;
  486.   s2 = insn.s2;
  487.  
  488.   printf("\t");
  489.   switch (insn.opcode)
  490.     {
  491. #if SPARC
  492.     case COPY:
  493.       if (IMMEDIATE_P(s1) && (IMMEDIATE_VAL(s1) & 0x1fff) == 0)
  494.     printf("sethi    %s,%s",NAME(s1),NAME(d));
  495.       else
  496.     printf("mov    %s,%s",NAME(s1),NAME(d));
  497.       break;
  498.     case ADD:    printf("add    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  499.     case ADD_CI:printf("addx    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  500.     case ADD_CO:printf("addcc    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  501.     case ADD_CIO:printf("addxcc    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  502.     case SUB:
  503.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  504.     printf("xnor    %%g0,%s,%s",NAME(s2),NAME(d));
  505.       else
  506.     printf("sub    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  507.       break;
  508.     case SUB_CI:printf("subx    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  509.     case SUB_CO:printf("subcc    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  510.     case SUB_CIO:printf("subxcc    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  511.     case AND:    printf("and    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  512.     case IOR:    printf("or    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  513.     case XOR:    printf("xor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  514.     case ANDC:    printf("andn    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  515.     case IORC:    printf("orn    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  516.     case EQV:    printf("xnor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  517.     case LSHIFTR:printf("srl    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  518.     case ASHIFTR:printf("sra    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  519.     case SHIFTL:printf("sll    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  520. #elif POWER
  521. #ifdef POWERPC            /* redefine the PowerPC names */
  522. #define INS_LIL        "li"
  523. #define INS_LIU        "li"
  524. #define INS_ORIL    "ori"
  525. #define INS_CAL        "addi"
  526. #define    INS_CAU        "addis"
  527. #define    INS_CAX        "add"
  528. #define    INS_AI        "addic"
  529. #define    INS_A        "addc"
  530. #define    INS_AME        "addme"
  531. #define    INS_AZE        "aze"
  532. #define    INS_AE        "adde"
  533. #define    INS_NEG        "neg"
  534. #define    INS_SF        "subfc"
  535. #define    INS_SUBF    "subf"
  536. #define    INS_SFI        "subfic"
  537. #define    INS_SFME    "subfme"
  538. #define    INS_SFZE    "subfze"
  539. #define    INS_SFE        "subfe"
  540. #define    INS_AND        "and"
  541. #define    INS_ORIU    "oris"
  542. #define    INS_ORIL    "ori"
  543. #define    INS_OR        "or"
  544. #define    INS_XORIL    "xori"
  545. #define    INS_XORIU    "xoris"
  546. #define    INS_XOR        "xor"
  547. #define    INS_ANDC    "andc"
  548. #define    INS_ORC        "orc"
  549. #define    INS_EQV        "eqv"
  550. #define    INS_NAND    "nand"
  551. #define    INS_NOR        "nor"
  552. #define    INS_SRI        "srwi"
  553. #define    INS_SRE        "srw"
  554. #define    INS_SRAI    "srawi"
  555. #define    INS_SREA    "sraw"
  556. #define    INS_SLI        "slwi"
  557. #define    INS_SLE        "slw"
  558. #define    INS_RLINM    "rlwimi"
  559. #define    INS_RLNM    "rlwnm"
  560. #define    INS_MULI    "mulli"
  561. #define    INS_MULS    "mullw"
  562. #define    INS_CNTLZ    "cntlzw"
  563. #define    INS_ABS        "abs (illegal)"
  564. #define    INS_NABS    "nabs (illegal)"
  565. #define    INS_DOZI    "dozi (illegal)"
  566. #define    INS_DOZ        "doz (illegal)"
  567.  
  568. #else  /* Power names, not PowerPC */
  569. #define INS_LIL        "lil"
  570. #define INS_LIU        "liu"
  571. #define INS_ORIL    "oril"
  572. #define INS_CAL        "cal"
  573. #define    INS_CAU        "cau"
  574. #define    INS_CAX        "cax"
  575. #define    INS_AI        "ai"
  576. #define    INS_A        "a"
  577. #define    INS_AME        "ame"
  578. #define    INS_AZE        "aze"
  579. #define    INS_AE        "ae"
  580. #define    INS_NEG        "neg"
  581. #define    INS_SF        "sf"
  582. #define    INS_SUBF    "subf (illegal)"
  583. #define    INS_SFI        "sfi"
  584. #define    INS_SFME    "sfme"
  585. #define    INS_SFZE    "sfze"
  586. #define    INS_SFE        "sfe"
  587. #define    INS_AND        "and"
  588. #define    INS_ORIU    "oriu"
  589. #define    INS_ORIL    "oril"
  590. #define    INS_OR        "or"
  591. #define    INS_XORIL    "xoril"
  592. #define    INS_XORIU    "xoriu"
  593. #define    INS_XOR        "xor"
  594. #define    INS_ANDC    "andc"
  595. #define    INS_ORC        "orc"
  596. #define    INS_EQV        "eqv"
  597. #define    INS_NAND    "nand"
  598. #define    INS_NOR        "nor"
  599. #define    INS_SRI        "sri"
  600. #define    INS_SRE        "sre"
  601. #define    INS_SRAI    "srai"
  602. #define    INS_SREA    "srea"
  603. #define    INS_SLI        "sli"
  604. #define    INS_SLE        "sle"
  605. #define    INS_RLINM    "rlinm"
  606. #define    INS_RLNM    "rlnm"
  607. #define    INS_MULI    "muli"
  608. #define    INS_MULS    "muls"
  609. #define    INS_CNTLZ    "cntlz"
  610. #define    INS_ABS        "abs"
  611. #define    INS_NABS    "nabs"
  612. #define    INS_DOZI    "dozi"
  613. #define    INS_DOZ        "doz"
  614. #endif /* POWER */
  615.  
  616.     case COPY:
  617.       if (IMMEDIATE_P(s1))
  618.     {
  619.       if (IMMEDIATE_VAL(s1) >= 0 && IMMEDIATE_VAL(s1) < 0x8000)
  620.         printf("%s\t%s,0x%x",INS_LIL,NAME(d),IMMEDIATE_VAL(s1));
  621.       else
  622.         printf("%s\t%s,%s",INS_LIU,NAME(d),NAME(s1));
  623.     }
  624.       else
  625.     printf("%s\t%s,%s,0",INS_ORIL,NAME(d),NAME(s1));
  626.       break;
  627.     case ADD:
  628.       if (IMMEDIATE_P(s2))
  629.     {
  630.       if (IMMEDIATE_VAL(s2) + 0x4000 < 0x8000)
  631.         printf("%s\t%s,%d(%s)",INS_CAL,NAME(d),IMMEDIATE_VAL(s2),NAME(s1));
  632.       else if ((IMMEDIATE_VAL(s2) & 0xffff) == 0)
  633.         printf("%s\t%s,%s,0x%x",INS_CAU,NAME(d),NAME(s1),IMMEDIATE_VAL(s2) >> 16);
  634.       else
  635.         abort ();
  636.     }
  637.       else
  638.     printf("%s\t%s,%s,%s",INS_CAX,NAME(d),NAME(s1),NAME(s2));
  639.       break;
  640.     case ADD_CO:
  641.       if (IMMEDIATE_P(s2))
  642.     printf("%s\t%s,%s,%s",INS_AI,NAME(d),NAME(s1),NAME(s2));
  643.       else
  644.     printf("%s\t%s,%s,%s",INS_A,NAME(d),NAME(s1),NAME(s2));
  645.       break;
  646.     case ADD_CIO:
  647.       if (IMMEDIATE_P(s2))
  648.     {
  649.       if (IMMEDIATE_VAL(s2) == -1)
  650.         printf("%s\t%s,%s",INS_AME,NAME(d),NAME(s1));
  651.       else if (IMMEDIATE_VAL(s2) == 0)
  652.         printf("%s\t%s,%s",INS_AZE,NAME(d),NAME(s1));
  653.     }
  654.       else
  655.     printf("%s\t%s,%s,%s",INS_AE,NAME(d),NAME(s1),NAME(s2));
  656.       break;
  657.     case SUB:
  658.       if (IMMEDIATE_P(s1))
  659.     {
  660.       if (IMMEDIATE_VAL(s1) == 0)
  661.         printf("%s\t%s,%s",INS_NEG,NAME(d),NAME(s2));
  662.       else if (IMMEDIATE_VAL(s1) == -1)
  663.         printf("%s\t%s,%s,%s",INS_NAND,NAME(d),NAME(s2),NAME(s2));
  664.     }
  665.       else
  666.     printf("%s\t%s,%s,%s",INS_SUBF,NAME(d),NAME(s2),NAME(s1));
  667.       break;
  668.     case ADC_CO:
  669.       if (IMMEDIATE_P(s1))
  670.     printf("%s\t%s,%s,%s",INS_SFI,NAME(d),NAME(s2),NAME(s1));
  671.       else
  672.     printf("%s\t%s,%s,%s",INS_SF,NAME(d),NAME(s2),NAME(s1));
  673.       break;
  674.     case ADC_CIO:
  675.       if (IMMEDIATE_P(s1))
  676.     {
  677.       if (IMMEDIATE_VAL(s1) == -1)
  678.         printf("%s\t%s,%s",INS_SFME,NAME(d),NAME(s2));
  679.       else if (IMMEDIATE_VAL(s1) == 0)
  680.         printf("%s\t%s,%s",INS_SFZE,NAME(d),NAME(s2));
  681.       else abort();
  682.     }
  683.       else
  684.     printf("%s\t%s,%s,%s",INS_SFE,NAME(d),NAME(s2),NAME(s1));
  685.       break;
  686.     case AND:
  687.       if (IMMEDIATE_P(s2))
  688.     {
  689.       if (IMMEDIATE_VAL(s2) == 0x80000000)
  690.         printf("%s\t%s,%s,0,0,0",INS_RLINM,NAME(d),NAME(s1));
  691.       else if (IMMEDIATE_VAL(s2) == 0x7fffffff)
  692.         printf("%s\t%s,%s,0,1,31",INS_RLINM,NAME(d),NAME(s1));
  693.       else if (IMMEDIATE_VAL(s2) == 1)
  694.         printf("%s\t%s,%s,0,31,31",INS_RLINM,NAME(d),NAME(s1));
  695.       else abort();
  696.     }
  697.       else
  698.     printf("%s\t%s,%s,%s",INS_AND,NAME(d),NAME(s1),NAME(s2));
  699.       break;
  700.     case IOR:
  701.       if (IMMEDIATE_P(s2))
  702.     {
  703.       if (IMMEDIATE_VAL(s2) == 0x80000000)
  704.         printf("%s\t%s,%s,0x8000",INS_ORIU,NAME(d),NAME(s1));
  705.       else abort();
  706.     }
  707.       else
  708.     printf("%s\t%s,%s,%s",INS_OR,NAME(d),NAME(s1),NAME(s2));
  709.       break;
  710.     case XOR:
  711.       if (IMMEDIATE_P(s2))
  712.     {
  713.       if (IMMEDIATE_VAL(s2) == 1)
  714.         printf("%s\t%s,%s,1",INS_XORIL,NAME(d),NAME(s1));
  715.       else if (IMMEDIATE_VAL(s2) == 0x80000000)
  716.         printf("%s\t%s,%s,0x8000",INS_XORIU,NAME(d),NAME(s1));
  717.       else abort();
  718.     }
  719.       else
  720.     printf("%s\t%s,%s,%s",INS_XOR,NAME(d),NAME(s1),NAME(s2));
  721.       break;
  722.     case ANDC:    printf("%s\t%s,%s,%s",INS_ANDC,NAME(d),NAME(s1),NAME(s2));break;
  723.     case IORC:    printf("%s\t%s,%s,%s",INS_ORC,NAME(d),NAME(s1),NAME(s2));break;
  724.     case EQV:    printf("%s\t%s,%s,%s",INS_EQV,NAME(d),NAME(s1),NAME(s2));break;
  725.     case NAND:    printf("%s\t%s,%s,%s",INS_NAND,NAME(d),NAME(s1),NAME(s2));break;
  726.     case NOR:    printf("%s\t%s,%s,%s",INS_NOR,NAME(d),NAME(s1),NAME(s2));break;
  727.     case LSHIFTR:
  728.       if (IMMEDIATE_P(s2))
  729.     printf("%s\t%s,%s,%s",INS_SRI,NAME(d),NAME(s1),NAME(s2));
  730.       else
  731.     printf("%s\t%s,%s,%s",INS_SRE,NAME(d),NAME(s1),NAME(s2));
  732.       break;
  733.     case ASHIFTR_CON:
  734.       if (IMMEDIATE_P(s2))
  735.     printf("%s\t%s,%s,%s",INS_SRAI,NAME(d),NAME(s1),NAME(s2));
  736.       else
  737.     printf("%s\t%s,%s,%s",INS_SREA,NAME(d),NAME(s1),NAME(s2));
  738.       break;
  739.     case SHIFTL:
  740.       if (IMMEDIATE_P(s2))
  741.     printf("%s\t%s,%s,%s",INS_SLI,NAME(d),NAME(s1),NAME(s2));
  742.       else
  743.     printf("%s\t%s,%s,%s",INS_SLE,NAME(d),NAME(s1),NAME(s2));
  744.       break;
  745.     case ROTATEL:
  746.       if (IMMEDIATE_P(s2))
  747.     printf("%s\t%s,%s,%s,0,31",INS_RLINM,NAME(d),NAME(s1),NAME(s2));
  748.       else
  749.     printf("%s\t%s,%s,%s,0,31",INS_RLNM,NAME(d),NAME(s1),NAME(s2));
  750.       break;
  751. #ifndef POWERPC
  752.     case ABSVAL:printf("%s\t%s,%s",INS_ABS,NAME(d),NAME(s1));break;
  753.     case NABSVAL:printf("%s\t%s,%s",INS_NABS,NAME(d),NAME(s1));break;
  754.     case DOZ:
  755.       if (IMMEDIATE_P(s1))
  756.     printf("%s\t%s,%s,%s",INS_DOZI,NAME(d),NAME(s2),NAME(s1));
  757.       else
  758.     printf("%s\t%s,%s,%s",INS_DOZ,NAME(d),NAME(s2),NAME(s1));
  759.       break;
  760. #endif
  761.     case MUL:
  762.       if (IMMEDIATE_P(s1))
  763.     printf("%s\t%s,%s,%s",INS_MULI,NAME(d),NAME(s2),NAME(s1));
  764.       else
  765.     printf("%s\t%s,%s,%s",INS_MULS,NAME(d),NAME(s2),NAME(s1));
  766.       break;
  767.     case CLZ:
  768.       printf("%s\t%s,%s",INS_CNTLZ,NAME(d),NAME(s1));break;
  769. #elif M88000
  770.     case COPY:
  771.       if (IMMEDIATE_P(s1))
  772.     {
  773.       if ((IMMEDIATE_VAL(s1) & 0xffff) == 0)
  774.         printf("or.u    %s,r0,0x%x",NAME(d),IMMEDIATE_VAL(s1));
  775.       else if ((IMMEDIATE_VAL(s1) & 0xffff0000) == 0)
  776.         printf("or    %s,r0,0x%x",NAME(d),IMMEDIATE_VAL(s1));
  777.       else if ((IMMEDIATE_VAL(s1) & 0xffff0000) == 0xffff0000)
  778.         printf("subu    %s,r0,0x%x",NAME(d),-IMMEDIATE_VAL(s1));
  779.       else
  780.         {
  781.           word x = IMMEDIATE_VAL(s1);
  782.           int i, j;
  783.           for (i = 31; i > 0; i--)
  784.         if ((x & (1 << i)) != 0)
  785.           break;
  786.           for (j = i; j >= 0; j--)
  787.         if ((x & (1 << j)) == 0)
  788.           break;
  789.           printf("set    %s,r0,%d<%d>",NAME(d), i - j, j + 1);
  790.         }
  791.     }
  792.       else
  793.     printf("or    %s,%s",NAME(d),NAME(s1));
  794.       break;
  795.     case ADD:    printf("addu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  796.     case ADD_CI:printf("addu.ci    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  797.     case ADD_CO:printf("addu.co    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  798.     case ADD_CIO:
  799.       if (IMMEDIATE_P(s2))
  800.     {
  801.       if (IMMEDIATE_VAL(s2) == -1)
  802.         {
  803.           printf("subu.cio %s,%s,r0",NAME(d),NAME(s1));
  804.           break;
  805.         }
  806.       if (IMMEDIATE_VAL(s2) != 0)
  807.         abort();
  808.     }
  809.       printf("addu.cio %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  810.       break;
  811.     case SUB:
  812.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  813.     printf("xor.c    %s,%s,r0",NAME(d),NAME(s2));
  814.       else
  815.     printf("subu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  816.       break;
  817.     case ADC_CI:printf("subu.ci    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  818.     case ADC_CO:printf("subu.co    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  819.     case ADC_CIO:printf("subu.cio %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  820.     case AND:
  821.       if (IMMEDIATE_P(s2))
  822.     {
  823.       if (IMMEDIATE_VAL(s2) == 0x80000000)
  824.         printf("mask.u    %s,%s,0x8000",NAME(d),NAME(s1));
  825.       else if (IMMEDIATE_VAL(s2) == 0x7fffffff)
  826.         printf("and.u    %s,%s,0x7fff",NAME(d),NAME(s1));
  827.       else if (IMMEDIATE_VAL(s2) == 1)
  828.         printf("mask    %s,%s,1",NAME(d),NAME(s1));
  829.       else abort();
  830.     }
  831.       else
  832.     printf("and    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  833.       break;
  834.     case IOR:
  835.       if (IMMEDIATE_P(s2))
  836.     {
  837.       if ((IMMEDIATE_VAL(s2) & 0xffff) == 0)
  838.         printf("or.u    %s,%s,0x%x",NAME(d),NAME(s1),
  839.            IMMEDIATE_VAL(s2)>>16);
  840.       else if (IMMEDIATE_VAL(s2) < 0x10000)
  841.         printf("or    %s,%s,0x%x",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  842.       else abort();
  843.     }
  844.       else
  845.     printf("or    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  846.       break;
  847.     case XOR:
  848.       if (IMMEDIATE_P(s2))
  849.     {
  850.       if ((IMMEDIATE_VAL(s2) & 0xffff) == 0)
  851.         printf("xor.u    %s,%s,0x%x",NAME(d),NAME(s1),
  852.            IMMEDIATE_VAL(s2)>>16);
  853.       else if (IMMEDIATE_VAL(s2) < 0x10000)
  854.         printf("xor    %s,%s,0x%x",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  855.       else abort();
  856.     }
  857.       else
  858.     printf("xor    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  859.       break;
  860.     case ANDC:    printf("and.c    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  861.     case IORC:    printf("or.c    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  862.     case EQV:    printf("xor.c    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  863.     case LSHIFTR:printf("extu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  864.     case ASHIFTR:printf("ext    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  865.     case SHIFTL:printf("mak    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  866.     case ROTATEL:
  867.       printf("rot    %s,%s,%d",NAME(d),NAME(s1),32-IMMEDIATE_VAL(s2));
  868.       break;
  869.     case FF1:
  870.       printf("ff1    %s,%s",NAME(d),NAME(s1));break;
  871.     case FF0:
  872.       printf("ff0    %s,%s",NAME(d),NAME(s1));break;
  873.     case CMPPAR:
  874.       if (IMMEDIATE_P(s2))
  875.     printf("cmp    %s,%s,0x%x",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  876.       else if (IMMEDIATE_P(s1))
  877.     printf("cmp    %s,r0,%s",NAME(d),NAME(s2));
  878.       else
  879.     printf("cmp    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  880.       break;
  881.     case EXTS1:
  882.       printf("ext    %s,%s,1<%d>",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  883.       break;
  884.     case EXTS2:
  885.       printf("ext    %s,%s,2<%d>",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  886.       break;
  887.     case EXTU1:
  888.       printf("extu    %s,%s,1<%d>",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  889.       break;
  890.     case EXTU2:
  891.       printf("extu    %s,%s,2<%d>",NAME(d),NAME(s1),IMMEDIATE_VAL(s2));
  892.       break;
  893.     case MUL:
  894.       printf("mul    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  895.       break;
  896. #elif AM29K
  897.     case COPY:
  898.       if (IMMEDIATE_P(s1))
  899.     {
  900.       if (IMMEDIATE_VAL(s1) < 0x10000)
  901.         printf("const    %s,0x%x",NAME(d),IMMEDIATE_VAL(s1));
  902.       else if (-IMMEDIATE_VAL(s1) < 0x10000)
  903.         printf("constn    %s,-0x%x",NAME(d),-IMMEDIATE_VAL(s1));
  904.       else if (IMMEDIATE_VAL(s1) == 0x80000000)
  905.         printf("cpeq    %s,gr1,gr1",NAME(d));
  906.       else abort();
  907.     }
  908.       else
  909.     printf("or    %s,%s,0",NAME(d),NAME(s1));
  910.       break;
  911.     case ADD_CO:
  912.       if (IMMEDIATE_P(s2) && (signed_word) IMMEDIATE_VAL(s2) < 0)
  913.     printf("sub    %s,%s,0x%x",NAME(d),NAME(s1),-IMMEDIATE_VAL(s2));
  914.       else
  915.     printf("add    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  916.       break;
  917.     case ADD_CIO:
  918.       if (IMMEDIATE_P(s2) && (signed_word) IMMEDIATE_VAL(s2) < 0)
  919.     printf("subc    %s,%s,0x%x",NAME(d),NAME(s1),-IMMEDIATE_VAL(s2));
  920.       else
  921.     printf("addc    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  922.       break;
  923.     case SUB:
  924.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  925.     printf("nor    %s,%s,0",NAME(d),NAME(s2));
  926.       else abort();
  927.       break;
  928.     case ADC_CO:printf("sub    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  929.     case ADC_CIO:printf("subc    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  930.     case AND:    printf("and    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  931.     case IOR:    printf("or    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  932.     case XOR:    printf("xor    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  933.     case ANDC:    printf("andn    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  934.     case EQV:    printf("xnor    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  935.     case NAND:    printf("nand    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  936.     case NOR:    printf("nor    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  937.     case LSHIFTR:printf("srl    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  938.     case ASHIFTR:printf("sra    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  939.     case SHIFTL:printf("sll    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  940.     case CPEQ:    printf("cpeq    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  941.     case CPGE:    printf("cpge    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  942.     case CPGEU:    printf("cpgeu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  943.     case CPGT:    printf("cpgt    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  944.     case CPGTU:    printf("cpgtu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  945.     case CPLE:    printf("cple    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  946.     case CPLEU:    printf("cpleu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  947.     case CPLT:    printf("cplt    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  948.     case CPLTU:    printf("cpltu    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  949.     case CPNEQ:    printf("cpneq    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));break;
  950.     case MUL:
  951.       printf("multiply    %s,%s,%s",NAME(d),NAME(s1),NAME(s2));
  952.       break;
  953.     case CLZ:
  954.       printf("clz    %s,%s",NAME(d),NAME(s1));break;
  955. #elif M68000
  956.     case COPY:
  957.       if (IMMEDIATE_P(s1))
  958.     {
  959.       if ((signed_word) IMMEDIATE_VAL(s1) >= -128
  960.           && (signed_word) IMMEDIATE_VAL(s1) < 128)
  961.         {
  962.           printf("moveq    #%ld,%s", IMMEDIATE_VAL(s1),NAME(d));
  963.           break;
  964.         }
  965.     }
  966.       printf("movel    %s,%s",NAME(s1),NAME(d));
  967.       break;
  968.     case EXCHANGE:
  969.       printf("exgl    %s,%s",NAME(s2),NAME(d));break;
  970.     case ADD_CO:
  971.       if (IMMEDIATE_P(s2)
  972.       && IMMEDIATE_VAL(s2) >= 1 && IMMEDIATE_VAL(s2) <= 8)
  973.     printf("addql    %s,%s",NAME(s2),NAME(d));
  974.       else
  975.     printf("addl    %s,%s",NAME(s2),NAME(d));
  976.       break;
  977.     case ADD_CIO:
  978.       printf("addxl    %s,%s",NAME(s2),NAME(d));break;
  979.     case SUB:
  980.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  981.     printf("notl    %s",NAME(d));
  982.       else abort();
  983.       break;
  984.     case SUB_CO:
  985.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == 0)
  986.     printf("negl    %s",NAME(d));
  987.       else if (IMMEDIATE_P(s2)
  988.            && IMMEDIATE_VAL(s2) >= 1 && IMMEDIATE_VAL(s2) <= 8)
  989.     printf("subql    %s,%s",NAME(s2),NAME(d));
  990.       else
  991.     printf("subl    %s,%s",NAME(s2),NAME(d));
  992.       break;
  993.     case SUB_CIO:
  994.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == 0)
  995.     printf("negxl    %s",NAME(d));
  996.       else
  997.     printf("subxl    %s,%s",NAME(s2),NAME(d));
  998.       break;
  999.     case AND:
  1000.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) + 0x8000 < 0x10000)
  1001.     printf("andw    %s,%s",NAME(s2),NAME(d));
  1002.       else
  1003.     printf("andl    %s,%s",NAME(s2),NAME(d));
  1004.       break;
  1005.     case IOR:
  1006.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) + 0x8000 < 0x10000)
  1007.     printf("orw    %s,%s",NAME(s2),NAME(d));
  1008.       else
  1009.     printf("orl    %s,%s",NAME(s2),NAME(d));
  1010.       break;
  1011.     case XOR:
  1012.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) + 0x8000 < 0x10000)
  1013.     printf("eorw    %s,%s",NAME(s2),NAME(d));
  1014.       else
  1015.     printf("eorl    %s,%s",NAME(s2),NAME(d));
  1016.       break;
  1017.     case LSHIFTR_CO:
  1018.       printf("lsrl    %s,%s",NAME(s2),NAME(d));break;
  1019.     case ASHIFTR_CO:
  1020.       printf("asrl    %s,%s",NAME(s2),NAME(d));break;
  1021.     case SHIFTL_CO:
  1022.       printf("lsll    %s,%s",NAME(s2),NAME(d));break;
  1023.     case ROTATEL_CO:
  1024.       printf("roll    %s,%s",NAME(s2),NAME(d));break;
  1025.     case ROTATEXL_CIO:
  1026.       printf("roxll    %s,%s",NAME(s2),NAME(d));break;
  1027.     case ROTATER_CO:
  1028.       printf("rorl    %s,%s",NAME(s2),NAME(d));break;
  1029.     case ROTATEXR_CIO:
  1030.       printf("roxrl    %s,%s",NAME(s2),NAME(d));break;
  1031.     case MUL:
  1032.       printf("mulsl    %s,%s",NAME(s2),NAME(d));break;
  1033. #elif I386
  1034.     case COPY:
  1035.       printf("movl    %s,%s",NAME(s1),NAME(d));break;
  1036.     case BSF86:
  1037.       printf("bsfl    %s,%s",NAME(s1),NAME(d));break;
  1038.     case EXCHANGE:
  1039.       printf("xchgl    %s,%s",NAME(s2),NAME(d));break;
  1040.     case ADD:
  1041.       if (IMMEDIATE_P(s2))
  1042.     {
  1043.       if (IMMEDIATE_VAL(s2) == 1)
  1044.         printf("incl    %s",NAME(d));
  1045.       else if (IMMEDIATE_VAL(s2) == -1)
  1046.         printf("decl    %s",NAME(d));
  1047.       else abort();
  1048.     }
  1049.       else abort();
  1050.       break;
  1051.     case ADD_CO:
  1052.       printf("addl    %s,%s",NAME(s2),NAME(d));break;
  1053.     case ADD_CIO:
  1054.       printf("adcl    %s,%s",NAME(s2),NAME(d));break;
  1055.     case SUB:
  1056.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  1057.     printf("notl    %s",NAME(d));
  1058.       else abort();
  1059.       break;
  1060.     case SUB_CO:
  1061.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == 0)
  1062.     printf("negl    %s",NAME(d));
  1063.       else
  1064.     printf("subl    %s,%s",NAME(s2),NAME(d));
  1065.       break;
  1066.     case SUB_CIO:
  1067.       printf("sbbl    %s,%s",NAME(s2),NAME(d));break;
  1068.     case CMP:
  1069.       printf("cmpl    %s,%s",NAME(s2),NAME(s1));break;
  1070.     case AND_RC:
  1071.       if (IMMEDIATE_P(s2) && (IMMEDIATE_VAL(s2) & 0xffffff00) == 0xffffff00)
  1072.     printf("andb    $%d,%s",IMMEDIATE_VAL(s2),NAME(d));
  1073.       else
  1074.     printf("andl    %s,%s",NAME(s2),NAME(d));
  1075.       break;
  1076.     case IOR_RC:
  1077.       if (IMMEDIATE_P(s2) && (IMMEDIATE_VAL(s2) & 0xffffff00) == 0)
  1078.     printf("orb    $%d,%s",IMMEDIATE_VAL(s2),NAME(d));
  1079.       else
  1080.     printf("orl    %s,%s",NAME(s2),NAME(d));
  1081.       break;
  1082.     case XOR_RC:
  1083.       if (IMMEDIATE_P(s2) && (IMMEDIATE_VAL(s2) & 0xffffff00) == 0)
  1084.     printf("xorb    $%d,%s",IMMEDIATE_VAL(s2),NAME(d));
  1085.       else
  1086.     printf("xorl    %s,%s",NAME(s2),NAME(d));
  1087.       break;
  1088.     case LSHIFTR_CO:
  1089.       printf("shrl    %s,%s",NAME(s2),NAME(d));break;
  1090.     case ASHIFTR_CO:
  1091.       printf("sarl    %s,%s",NAME(s2),NAME(d));break;
  1092.     case SHIFTL_CO:
  1093.       printf("shll    %s,%s",NAME(s2),NAME(d));break;
  1094.     case ROTATEL_CO:
  1095.       printf("roll    %s,%s",NAME(s2),NAME(d));break;
  1096.     case ROTATEXL_CIO:
  1097.       printf("rlcl    %s,%s",NAME(s2),NAME(d));break;
  1098.     case ROTATER_CO:
  1099.       printf("rorl    %s,%s",NAME(s2),NAME(d));break;
  1100.     case ROTATEXR_CIO:
  1101.       printf("rrcl    %s,%s",NAME(s2),NAME(d));break;
  1102.     case COMCY:
  1103.       printf("cmc");break;
  1104.     case MUL:
  1105.       printf("imull    %s,%s",NAME(s2),NAME(d));break;
  1106. #elif PYR
  1107.     case COPY:
  1108.       printf("movw    %s,%s",NAME(s1),NAME(d));break;
  1109.     case EXCHANGE:
  1110.       printf("xchw    %s,%s",NAME(s2),NAME(d));break;
  1111.     case ADD:
  1112.       printf("mova    0x%x(%s),%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1113.       break;
  1114.     case ADD_CO:
  1115.       printf("addw    %s,%s",NAME(s2),NAME(d));break;
  1116.     case ADD_CIO:
  1117.       printf("addwc    %s,%s",NAME(s2),NAME(d));break;
  1118.     case ADC_CO:
  1119.       if (IMMEDIATE_P(s1))
  1120.     printf("rsubw    %s,%s",NAME(s1),NAME(d));
  1121.       else
  1122.     printf("subw    %s,%s",NAME(s2),NAME(d));
  1123.       break;
  1124.     case ADC_CIO:
  1125.       printf("subwb    %s,%s",NAME(s2),NAME(d));break;
  1126.     case AND_CC:
  1127.       printf("andw    %s,%s",NAME(s2),NAME(d));break;
  1128.     case IOR_CC:
  1129.       printf("orw    %s,%s",NAME(s2),NAME(d));break;
  1130.     case XOR_CC:
  1131.       printf("xorw    %s,%s",NAME(s2),NAME(d));break;
  1132.     case ANDC_CC:
  1133.       printf("bicw    %s,%s",NAME(s2),NAME(d));break;
  1134.     case LSHIFTR_CO:
  1135.       printf("lshrw    %s,%s",NAME(s2),NAME(d));break;
  1136.     case ASHIFTR_CO:
  1137.       printf("ashrw    %s,%s",NAME(s2),NAME(d));break;
  1138.     case SHIFTL_CO:
  1139.       printf("lshlw    %s,%s",NAME(s2),NAME(d));break;
  1140.     case ROTATEL_CO:
  1141.       printf("rotlw    %s,%s",NAME(s2),NAME(d));break;
  1142.     case ROTATER_CO:
  1143.       printf("rotrw    %s,%s",NAME(s2),NAME(d));break;
  1144.     case MUL:
  1145.       printf("mulw    %s,%s",NAME(s2),NAME(d));break;
  1146. #elif ALPHA
  1147.     case COPY:
  1148.       if (IMMEDIATE_P(s1))
  1149.     printf("lda    %s,%s",NAME(d),NAME(s1)); /* yes, reversed op order */
  1150.       else
  1151.     printf("bis    %s,%s,%s",NAME(s1),NAME(s1),NAME(d));
  1152.       break;
  1153.     case ADD:
  1154.       if (IMMEDIATE_P(s2) && (signed_word) IMMEDIATE_VAL(s2) < 0)
  1155.     /* Cast value to int since we cannot portably print a 64 bit type.  */
  1156.     printf("subq    %s,%d,%s",NAME(s1),(int) -IMMEDIATE_VAL(s2),NAME(d));
  1157.       else
  1158.     printf("addq    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1159.       break;
  1160.     case SUB:
  1161.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  1162.     printf("ornot    $31,%s,%s",NAME(s2),NAME(d));
  1163.       else
  1164.     printf("subq    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1165.       break;
  1166.     case AND:    printf("and    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1167.     case IOR:    printf("bis    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1168.     case XOR:    printf("xor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1169.     case ANDC:    printf("bic    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1170.     case IORC:    printf("ornot    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1171.     case EQV:    printf("eqv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1172.     case LSHIFTR:printf("srl    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1173.     case ASHIFTR:printf("sra    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1174.     case SHIFTL:printf("sll    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1175.     case CMPEQ:    printf("cmpeq    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1176.     case CMPLE:    printf("cmple    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1177.     case CMPLEU:printf("cmpule    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1178.     case CMPLT:    printf("cmplt    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1179.     case CMPLTU:printf("cmpult    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1180.     case CMOVEQ:printf("cmoveq    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1181.     case CMOVNE:printf("cmovne    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1182.     case CMOVLT:printf("cmovlt    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1183.     case CMOVGE:printf("cmovge    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1184.     case CMOVLE:printf("cmovle    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1185.     case CMOVGT:printf("cmovgt    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  1186. #elif HPPA
  1187.     case ADD_CIO:
  1188.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1189.     printf("subb        %s,%%r0,%s",NAME(s1),NAME(d));
  1190.       else
  1191.     printf("addc        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1192.       break;
  1193.     case ADC_CIO:
  1194.       printf("subb        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1195.       break;
  1196.     case ADD_CO:
  1197.       if (IMMEDIATE_P(s2))
  1198.     printf("addi        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1199.       else
  1200.     printf("add        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1201.       break;
  1202.     case ADC_CO:
  1203.       if (IMMEDIATE_P(s1))
  1204.     printf("subi        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1205.       else
  1206.     printf("sub        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1207.       break;
  1208.     case ADD:
  1209.       if (IMMEDIATE_P(s2))
  1210.     printf("ldo        %d(%s),%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1211.       else
  1212.     printf("addl        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1213.       break;
  1214.     case ADDCMPL:
  1215.       printf("uaddcm        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1216.       break;
  1217.     case AND:
  1218.       if (IMMEDIATE_P(s2))
  1219.     printf("extru        %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1220.       else
  1221.     printf("and        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1222.       break;
  1223.     case IOR:
  1224.       printf("or        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1225.       break;
  1226.     case XOR:
  1227.       printf("xor        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1228.       break;
  1229.     case ANDC:
  1230.       printf("andcm        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1231.       break;
  1232.     case SUB:
  1233.       printf("andcm        %%r0,%s,%s",NAME(s2),NAME(d));
  1234.       break;
  1235.     case LSHIFTR:
  1236.       printf("extru        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1237.       break;
  1238.     case ASHIFTR:
  1239.       printf("extrs        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1240.       break;
  1241.     case SHIFTL:
  1242.       printf("zdep        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1243.       break;
  1244.     case ROTATEL:
  1245.       printf("shd        %s,%s,%d,%s",NAME(s1),NAME(s1),32-IMMEDIATE_VAL(s2),NAME(d));
  1246.       break;
  1247.     case EXTS1:
  1248.       if (!IMMEDIATE_P(s2))
  1249.     abort();
  1250.       printf("extrs        %s,%d,1,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  1251.       break;
  1252.     case EXTU1:
  1253.       if (!IMMEDIATE_P(s2))
  1254.     abort();
  1255.       printf("extru        %s,%d,1,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  1256.       break;
  1257.     case EXTS2:
  1258.       if (!IMMEDIATE_P(s2))
  1259.     abort();
  1260.       printf("extrs        %s,%d,2,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  1261.       break;
  1262.     case EXTU2:
  1263.       if (!IMMEDIATE_P(s2))
  1264.     abort();
  1265.       printf("extru        %s,%d,2,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  1266.       break;
  1267.     case COPY:
  1268.       if (IMMEDIATE_P(s1))
  1269.     {
  1270.       if (IMMEDIATE_VAL(s1) + 0x2000 < 0x4000)
  1271.         printf("ldi        %d,%s",IMMEDIATE_VAL(s1),NAME(d));
  1272.       else if ((IMMEDIATE_VAL(s1) & 0x7ff) == 0)
  1273.         printf("ldil        l'0x%x,%s",IMMEDIATE_VAL(s1),NAME(d));
  1274.       else if (IMMEDIATE_VAL(s1) == 0x7fffffff)
  1275.         printf("zdepi        -1,31,31,%s",NAME(d));
  1276.       else
  1277.         abort();
  1278.     }
  1279.       else
  1280.     printf("copy        %s,%s",NAME(s1),NAME(d));
  1281.       break;
  1282.     case ADD_CIO_SEQ:
  1283.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1284.     printf("subb,=        %s,%%r0,%s",NAME(s1),NAME(d));
  1285.       else
  1286.     printf("addc,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1287.       break;
  1288.     case ADC_CIO_SEQ:
  1289.       printf("subb,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1290.       break;
  1291.     case ADD_CO_SEQ:
  1292.       if (IMMEDIATE_P(s2))
  1293.     printf("addi,=        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1294.       else
  1295.     printf("add,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1296.       break;
  1297.     case ADC_CO_SEQ:
  1298.       if (IMMEDIATE_P(s1))
  1299.     printf("subi,=        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1300.       else
  1301.     printf("sub,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1302.       break;
  1303.     case ADD_SEQ:
  1304.       if (IMMEDIATE_P(s2))
  1305.     abort();
  1306.       else
  1307.     printf("addl,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1308.       break;
  1309.     case COMCLR_SEQ:
  1310.       if (IMMEDIATE_P(s1))
  1311.     printf("comiclr,=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1312.       else
  1313.     printf("comclr,=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1314.       break;
  1315.     case AND_SEQ:
  1316.       if (IMMEDIATE_P(s2))
  1317.     printf("extru,=        %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1318.       else
  1319.     printf("and,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1320.       break;
  1321.     case IOR_SEQ:
  1322.       printf("or,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1323.       break;
  1324.     case XOR_SEQ:
  1325.       printf("xor,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1326.       break;
  1327.     case ANDC_SEQ:
  1328.       printf("andcm,=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1329.       break;
  1330.     case SUB_SEQ:
  1331.       printf("andcm,=        %%r0,%s,%s",NAME(s2),NAME(d));
  1332.       break;
  1333. #if LATER
  1334.     case LSHIFTR_SEQ:
  1335.       printf("extru,=        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1336.       break;
  1337.     case ASHIFTR_SEQ:
  1338.       printf("extrs,=        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1339.       break;
  1340.     case SHIFTL_SEQ:
  1341.       printf("zdep,=        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1342.       break;
  1343.     case ROTATEL_SEQ:
  1344.     case EXTS1_SEQ:
  1345.     case EXTU1_SEQ:
  1346.     case EXTS2_SEQ:
  1347.     case EXTU2_SEQ:
  1348.       abort();
  1349.     case COPY_SEQ:
  1350.       abort();
  1351. #endif
  1352.  
  1353.     case ADD_CIO_SNE:
  1354.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1355.     printf("subb,<>        %s,%%r0,%s",NAME(s1),NAME(d));
  1356.       else
  1357.     printf("addc,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1358.       break;
  1359.     case ADC_CIO_SNE:
  1360.       printf("subb,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1361.       break;
  1362.     case ADD_CO_SNE:
  1363.       if (IMMEDIATE_P(s2))
  1364.     printf("addi,<>        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1365.       else
  1366.     printf("add,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1367.       break;
  1368.     case ADC_CO_SNE:
  1369.       if (IMMEDIATE_P(s1))
  1370.     printf("subi,<>        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1371.       else
  1372.     printf("sub,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1373.       break;
  1374.     case ADD_SNE:
  1375.       if (IMMEDIATE_P(s2))
  1376.     abort();
  1377.       else
  1378.     printf("addl,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1379.       break;
  1380.     case COMCLR_SNE:
  1381.       if (IMMEDIATE_P(s1))
  1382.     printf("comiclr,<>    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1383.       else
  1384.     printf("comclr,<>    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1385.       break;
  1386.     case AND_SNE:
  1387.       if (IMMEDIATE_P(s2))
  1388.     printf("extru,<>    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1389.       else
  1390.     printf("and,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1391.       break;
  1392.     case IOR_SNE:
  1393.       printf("or,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1394.       break;
  1395.     case XOR_SNE:
  1396.       printf("xor,<>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1397.       break;
  1398.     case ANDC_SNE:
  1399.       printf("andcm,<>    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1400.       break;
  1401.     case SUB_SNE:
  1402.       printf("andcm,<>    %%r0,%s,%s",NAME(s2),NAME(d));
  1403.       break;
  1404. #if LATER
  1405.     case LSHIFTR_SNE:
  1406.       printf("extru,<>    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1407.       break;
  1408.     case ASHIFTR_SNE:
  1409.       printf("extrs,<>    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1410.       break;
  1411.     case SHIFTL_SNE:
  1412.       printf("zdep,<>        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1413.       break;
  1414.     case ROTATEL_SNE:
  1415.     case EXTS1_SNE:
  1416.     case EXTU1_SNE:
  1417.     case EXTS2_SNE:
  1418.     case EXTU2_SNE:
  1419.       abort();
  1420.     case COPY_SNE:
  1421.       abort();
  1422. #endif
  1423.  
  1424. #if LATER
  1425.     case ADD_CIO_SLTS:
  1426.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1427.     printf("subb,<        %s,%%r0,%s",NAME(s1),NAME(d));
  1428.       else
  1429.     printf("addc,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1430.       break;
  1431.     case ADC_CIO_SLTS:
  1432.       printf("subb,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1433.       break;
  1434.     case ADD_CO_SLTS:
  1435.       if (IMMEDIATE_P(s2))
  1436.     printf("addi,<        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1437.       else
  1438.     printf("add,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1439.       break;
  1440.     case ADC_CO_SLTS:
  1441.       if (IMMEDIATE_P(s1))
  1442.     printf("subi,<        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1443.       else
  1444.     printf("sub,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1445.       break;
  1446. #endif
  1447.     case ADD_SLTS:
  1448.       if (IMMEDIATE_P(s2))
  1449.     abort();
  1450.       else
  1451.     printf("addl,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1452.       break;
  1453.     case COMCLR_SLTS:
  1454.       if (IMMEDIATE_P(s1))
  1455.     printf("comiclr,<    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1456.       else
  1457.     printf("comclr,<    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1458.       break;
  1459.     case AND_SLTS:
  1460.       if (IMMEDIATE_P(s2))
  1461.     printf("extru,<        %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1462.       else
  1463.     printf("and,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1464.       break;
  1465.     case IOR_SLTS:
  1466.       printf("or,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1467.       break;
  1468.     case XOR_SLTS:
  1469.       printf("xor,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1470.       break;
  1471.     case ANDC_SLTS:
  1472.       printf("andcm,<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1473.       break;
  1474.     case SUB_SLTS:
  1475.       printf("andcm,<        %%r0,%s,%s",NAME(s2),NAME(d));
  1476.       break;
  1477. #if LATER
  1478.     case LSHIFTR_SLTS:
  1479.       printf("extru,<        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1480.       break;
  1481.     case ASHIFTR_SLTS:
  1482.       printf("extrs,<        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1483.       break;
  1484.     case SHIFTL_SLTS:
  1485.       printf("zdep,<        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1486.       break;
  1487.     case ROTATEL_SLTS:
  1488.     case EXTS1_SLTS:
  1489.     case EXTU1_SLTS:
  1490.     case EXTS2_SLTS:
  1491.     case EXTU2_SLTS:
  1492.       abort();
  1493.     case COPY_SLTS:
  1494.       abort();
  1495. #endif
  1496.  
  1497. #if LATER
  1498.     case ADD_CIO_SGES:
  1499.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1500.     printf("subb,>=        %s,%%r0,%s",NAME(s1),NAME(d));
  1501.       else
  1502.     printf("addc,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1503.       break;
  1504.     case ADC_CIO_SGES:
  1505.       printf("subb,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1506.       break;
  1507.     case ADD_CO_SGES:
  1508.       if (IMMEDIATE_P(s2))
  1509.     printf("addi,>=        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1510.       else
  1511.     printf("add,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1512.       break;
  1513.     case ADC_CO_SGES:
  1514.       if (IMMEDIATE_P(s1))
  1515.     printf("subi,>=        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1516.       else
  1517.     printf("sub,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1518.       break;
  1519. #endif
  1520.     case ADD_SGES:
  1521.       if (IMMEDIATE_P(s2))
  1522.     abort();
  1523.       else
  1524.     printf("addl,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1525.       break;
  1526.     case COMCLR_SGES:
  1527.       if (IMMEDIATE_P(s1))
  1528.     printf("comiclr,>=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1529.       else
  1530.     printf("comclr,>=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1531.       break;
  1532.     case AND_SGES:
  1533.       if (IMMEDIATE_P(s2))
  1534.     printf("extru,>=    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1535.       else
  1536.     printf("and,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1537.       break;
  1538.     case IOR_SGES:
  1539.       printf("or,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1540.       break;
  1541.     case XOR_SGES:
  1542.       printf("xor,>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1543.       break;
  1544.     case ANDC_SGES:
  1545.       printf("andcm,>=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1546.       break;
  1547.     case SUB_SGES:
  1548.       printf("andcm,>=    %%r0,%s,%s",NAME(s2),NAME(d));
  1549.       break;
  1550. #if LATER
  1551.     case LSHIFTR_SGES:
  1552.       printf("extru,>=    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1553.       break;
  1554.     case ASHIFTR_SGES:
  1555.       printf("extrs,>=    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1556.       break;
  1557.     case SHIFTL_SGES:
  1558.       printf("zdep,>=        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1559.       break;
  1560.     case ROTATEL_SGES:
  1561.     case EXTS1_SGES:
  1562.     case EXTU1_SGES:
  1563.     case EXTS2_SGES:
  1564.     case EXTU2_SGES:
  1565.       abort();
  1566.     case COPY_SGES:
  1567.       abort();
  1568. #endif
  1569.  
  1570. #if LATER
  1571.     case ADD_CIO_SLES:
  1572.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1573.     printf("subb,<=        %s,%%r0,%s",NAME(s1),NAME(d));
  1574.       else
  1575.     printf("addc,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1576.       break;
  1577.     case ADC_CIO_SLES:
  1578.       printf("subb,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1579.       break;
  1580.     case ADD_CO_SLES:
  1581.       if (IMMEDIATE_P(s2))
  1582.     printf("addi,<=        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1583.       else
  1584.     printf("add,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1585.       break;
  1586.     case ADC_CO_SLES:
  1587.       if (IMMEDIATE_P(s1))
  1588.     printf("subi,<=        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1589.       else
  1590.     printf("sub,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1591.       break;
  1592. #endif
  1593.     case ADD_SLES:
  1594.       if (IMMEDIATE_P(s2))
  1595.     abort();
  1596.       else
  1597.     printf("addl,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1598.       break;
  1599.     case COMCLR_SLES:
  1600.       if (IMMEDIATE_P(s1))
  1601.     printf("comiclr,<=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1602.       else
  1603.     printf("comclr,<=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1604.       break;
  1605.     case AND_SLES:
  1606.       if (IMMEDIATE_P(s2))
  1607.     printf("extru,<=    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1608.       else
  1609.     printf("and,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1610.       break;
  1611.     case IOR_SLES:
  1612.       printf("or,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1613.       break;
  1614.     case XOR_SLES:
  1615.       printf("xor,<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1616.       break;
  1617.     case ANDC_SLES:
  1618.       printf("andcm,<=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1619.       break;
  1620.     case SUB_SLES:
  1621.       printf("andcm,<=    %%r0,%s,%s",NAME(s2),NAME(d));
  1622.       break;
  1623. #if LATER
  1624.     case LSHIFTR_SLES:
  1625.       printf("extru,<=    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1626.       break;
  1627.     case ASHIFTR_SLES:
  1628.       printf("extrs,<=    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1629.       break;
  1630.     case SHIFTL_SLES:
  1631.       printf("zdep,<=        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1632.       break;
  1633.     case ROTATEL_SLES:
  1634.     case EXTS1_SLES:
  1635.     case EXTU1_SLES:
  1636.     case EXTS2_SLES:
  1637.     case EXTU2_SLES:
  1638.       abort();
  1639.     case COPY_SLES:
  1640.       abort();
  1641. #endif
  1642.  
  1643. #if LATER
  1644.     case ADD_CIO_SGTS:
  1645.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1646.     printf("subb,>        %s,%%r0,%s",NAME(s1),NAME(d));
  1647.       else
  1648.     printf("addc,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1649.       break;
  1650.     case ADC_CIO_SGTS:
  1651.       printf("subb,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1652.       break;
  1653.     case ADD_CO_SGTS:
  1654.       if (IMMEDIATE_P(s2))
  1655.     printf("addi,>        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1656.       else
  1657.     printf("add,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1658.       break;
  1659.     case ADC_CO_SGTS:
  1660.       if (IMMEDIATE_P(s1))
  1661.     printf("subi,>        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1662.       else
  1663.     printf("sub,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1664.       break;
  1665. #endif
  1666.     case ADD_SGTS:
  1667.       if (IMMEDIATE_P(s2))
  1668.     abort();
  1669.       else
  1670.     printf("addl,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1671.       break;
  1672.     case COMCLR_SGTS:
  1673.       if (IMMEDIATE_P(s1))
  1674.     printf("comiclr,>    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1675.       else
  1676.     printf("comclr,>    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1677.       break;
  1678.     case AND_SGTS:
  1679.       if (IMMEDIATE_P(s2))
  1680.     printf("extru,>        %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1681.       else
  1682.     printf("and,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1683.       break;
  1684.     case IOR_SGTS:
  1685.       printf("or,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1686.       break;
  1687.     case XOR_SGTS:
  1688.       printf("xor,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1689.       break;
  1690.     case ANDC_SGTS:
  1691.       printf("andcm,>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1692.       break;
  1693.     case SUB_SGTS:
  1694.       printf("andcm,>        %%r0,%s,%s",NAME(s2),NAME(d));
  1695.       break;
  1696. #if LATER
  1697.     case LSHIFTR_SGTS:
  1698.       printf("extru,>        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1699.       break;
  1700.     case ASHIFTR_SGTS:
  1701.       printf("extrs,>        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1702.       break;
  1703.     case SHIFTL_SGTS:
  1704.       printf("zdep,>        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1705.       break;
  1706.     case ROTATEL_SGTS:
  1707.     case EXTS1_SGTS:
  1708.     case EXTU1_SGTS:
  1709.     case EXTS2_SGTS:
  1710.     case EXTU2_SGTS:
  1711.       abort();
  1712.     case COPY_SGTS:
  1713.       abort();
  1714. #endif
  1715.  
  1716.     case ADD_CIO_SLTU:
  1717.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1718.     printf("subb,<<        %s,%%r0,%s",NAME(s1),NAME(d));
  1719.       else
  1720.     printf("addc,nuv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1721.       break;
  1722.     case ADC_CIO_SLTU:
  1723.       printf("subb,<<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1724.       break;
  1725.     case ADD_CO_SLTU:
  1726.       if (IMMEDIATE_P(s2))
  1727.     printf("addi,nuv    %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1728.       else
  1729.     printf("add,nuv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1730.       break;
  1731.     case ADC_CO_SLTU:
  1732.       if (IMMEDIATE_P(s1))
  1733.     printf("subi,<<        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1734.       else
  1735.     printf("sub,<<        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1736.       break;
  1737.     case ADD_SLTU:
  1738.       if (IMMEDIATE_P(s2))
  1739.     abort();
  1740.       else
  1741.     printf("addl,nuv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1742.       break;
  1743.     case COMCLR_SLTU:
  1744.       if (IMMEDIATE_P(s1))
  1745.     printf("comiclr,<<    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1746.       else
  1747.     printf("comclr,<<    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1748.       break;
  1749.  
  1750.     case ADD_CIO_SGEU:
  1751.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1752.     printf("subb,>>=    %s,%%r0,%s",NAME(s1),NAME(d));
  1753.       else
  1754.     printf("addc,uv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1755.       break;
  1756.     case ADC_CIO_SGEU:
  1757.       printf("subb,>>=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1758.       break;
  1759.     case ADD_CO_SGEU:
  1760.       if (IMMEDIATE_P(s2))
  1761.     printf("addi,uv        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1762.       else
  1763.     printf("add,uv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1764.       break;
  1765.     case ADC_CO_SGEU:
  1766.       if (IMMEDIATE_P(s1))
  1767.     printf("subi,>>=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1768.       else
  1769.     printf("sub,>>=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1770.       break;
  1771.     case ADD_SGEU:
  1772.       if (IMMEDIATE_P(s2))
  1773.     abort();
  1774.       else
  1775.     printf("addl,uv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1776.       break;
  1777.     case COMCLR_SGEU:
  1778.       if (IMMEDIATE_P(s1))
  1779.     printf("comiclr,>>=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1780.       else
  1781.     printf("comclr,>>=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1782.       break;
  1783.  
  1784.     case ADD_CIO_SLEU:
  1785.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1786.     printf("subb,<<=    %s,%%r0,%s",NAME(s1),NAME(d));
  1787.       else
  1788.     printf("addc,znv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1789.       break;
  1790.     case ADC_CIO_SLEU:
  1791.       printf("subb,<<=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1792.       break;
  1793.     case ADD_CO_SLEU:
  1794.       if (IMMEDIATE_P(s2))
  1795.     printf("addi,znv    %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1796.       else
  1797.     printf("add,znv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1798.       break;
  1799.     case ADC_CO_SLEU:
  1800.       if (IMMEDIATE_P(s1))
  1801.     printf("subi,<<=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1802.       else
  1803.     printf("sub,<<=        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1804.       break;
  1805.     case ADD_SLEU:
  1806.       if (IMMEDIATE_P(s2))
  1807.     abort();
  1808.       else
  1809.     printf("addl,znv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1810.       break;
  1811.     case COMCLR_SLEU:
  1812.       if (IMMEDIATE_P(s1))
  1813.     printf("comiclr,<<=    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1814.       else
  1815.     printf("comclr,<<=    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1816.       break;
  1817.  
  1818.     case ADD_CIO_SGTU:
  1819.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1820.     printf("subb,>>        %s,%%r0,%s",NAME(s1),NAME(d));
  1821.       else
  1822.     printf("addc,vnz    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1823.       break;
  1824.     case ADC_CIO_SGTU:
  1825.       printf("subb,>>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1826.       break;
  1827.     case ADD_CO_SGTU:
  1828.       if (IMMEDIATE_P(s2))
  1829.     printf("addi,vnz    %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1830.       else
  1831.     printf("add,vnz        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1832.       break;
  1833.     case ADC_CO_SGTU:
  1834.       if (IMMEDIATE_P(s1))
  1835.     printf("subi,>>        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1836.       else
  1837.     printf("sub,>>        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1838.       break;
  1839.     case ADD_SGTU:
  1840.       if (IMMEDIATE_P(s2))
  1841.     abort();
  1842.       else
  1843.     printf("addl,vnz    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1844.       break;
  1845.     case COMCLR_SGTU:
  1846.       if (IMMEDIATE_P(s1))
  1847.     printf("comiclr,>>    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1848.       else
  1849.     printf("comclr,>>    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1850.       break;
  1851.  
  1852.     case ADD_CIO_SODD:
  1853.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1854.     printf("subb,od        %s,%%r0,%s",NAME(s1),NAME(d));
  1855.       else
  1856.     printf("addc,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1857.       break;
  1858.     case ADC_CIO_SODD:
  1859.       printf("subb,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1860.       break;
  1861.     case ADD_CO_SODD:
  1862.       if (IMMEDIATE_P(s2))
  1863.     printf("addi,od        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1864.       else
  1865.     printf("add,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1866.       break;
  1867.     case ADC_CO_SODD:
  1868.       if (IMMEDIATE_P(s1))
  1869.     printf("subi,od        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1870.       else
  1871.     printf("sub,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1872.       break;
  1873.     case ADD_SODD:
  1874.       if (IMMEDIATE_P(s2))
  1875.     abort();
  1876.       else
  1877.     printf("addl,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1878.       break;
  1879.     case COMCLR_SODD:
  1880.       if (IMMEDIATE_P(s1))
  1881.     printf("comiclr,od    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1882.       else
  1883.     printf("comclr,od    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1884.       break;
  1885.     case AND_SODD:
  1886.       if (IMMEDIATE_P(s2))
  1887.     printf("extru,od    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1888.       else
  1889.     printf("and,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1890.       break;
  1891.     case IOR_SODD:
  1892.       printf("or,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1893.       break;
  1894.     case XOR_SODD:
  1895.       printf("xor,od        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1896.       break;
  1897.     case ANDC_SODD:
  1898.       printf("andcm,od    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1899.       break;
  1900.     case SUB_SODD:
  1901.       printf("andcm,od    %%r0,%s,%s",NAME(s2),NAME(d));
  1902.       break;
  1903. #if LATER
  1904.     case LSHIFTR_SODD:
  1905.       printf("extru,od    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1906.       break;
  1907.     case ASHIFTR_SODD:
  1908.       printf("extrs,od    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1909.       break;
  1910.     case SHIFTL_SODD:
  1911.       printf("zdep,od        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1912.       break;
  1913.     case ROTATEL_SODD:
  1914.     case EXTS1_SODD:
  1915.     case EXTU1_SODD:
  1916.     case EXTS2_SODD:
  1917.     case EXTU2_SODD:
  1918.       abort();
  1919.     case COPY_SODD:
  1920.       abort();
  1921. #endif
  1922.  
  1923.     case ADD_CIO_SEVN:
  1924.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  1925.     printf("subb,ev        %s,%%r0,%s",NAME(s1),NAME(d));
  1926.       else
  1927.     printf("addc,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1928.       break;
  1929.     case ADC_CIO_SEVN:
  1930.       printf("subb,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1931.       break;
  1932.     case ADD_CO_SEVN:
  1933.       if (IMMEDIATE_P(s2))
  1934.     printf("addi,ev        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  1935.       else
  1936.     printf("add,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1937.       break;
  1938.     case ADC_CO_SEVN:
  1939.       if (IMMEDIATE_P(s1))
  1940.     printf("subi,ev        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1941.       else
  1942.     printf("sub,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1943.       break;
  1944.     case ADD_SEVN:
  1945.       if (IMMEDIATE_P(s2))
  1946.     abort();
  1947.       else
  1948.     printf("addl,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1949.       break;
  1950.     case COMCLR_SEVN:
  1951.       if (IMMEDIATE_P(s1))
  1952.     printf("comiclr,ev    %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  1953.       else
  1954.     printf("comclr,ev    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1955.       break;
  1956.     case AND_SEVN:
  1957.       if (IMMEDIATE_P(s2))
  1958.     printf("extru,ev    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  1959.       else
  1960.     printf("and,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1961.       break;
  1962.     case IOR_SEVN:
  1963.       printf("or,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1964.       break;
  1965.     case XOR_SEVN:
  1966.       printf("xor,ev        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1967.       break;
  1968.     case ANDC_SEVN:
  1969.       printf("andcm,ev    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1970.       break;
  1971.     case SUB_SEVN:
  1972.       printf("andcm,ev    %%r0,%s,%s",NAME(s2),NAME(d));
  1973.       break;
  1974. #if LATER
  1975.     case LSHIFTR_SEVN:
  1976.       printf("extru,ev    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1977.       break;
  1978.     case ASHIFTR_SEVN:
  1979.       printf("extrs,ev    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1980.       break;
  1981.     case SHIFTL_SEVN:
  1982.       printf("zdep,ev        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  1983.       break;
  1984.     case ROTATEL_SEVN:
  1985.     case EXTS1_SEVN:
  1986.     case EXTU1_SEVN:
  1987.     case EXTS2_SEVN:
  1988.     case EXTU2_SEVN:
  1989.       abort();
  1990.     case COPY_SEVN:
  1991.       abort();
  1992. #endif
  1993.  
  1994.     case ADD_SOVS:
  1995.       if (IMMEDIATE_P(s2))
  1996.     abort();
  1997.       else
  1998.     printf("addl,sv        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  1999.       break;
  2000.     case ADD_SNVS:
  2001.       if (IMMEDIATE_P(s2))
  2002.     abort();
  2003.       else
  2004.     printf("addl,nsv    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2005.       break;
  2006.  
  2007.     case ADD_CIO_S:
  2008.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == -1)
  2009.     printf("subb,tr        %s,%%r0,%s",NAME(s1),NAME(d));
  2010.       else
  2011.     printf("addc,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2012.       break;
  2013.     case ADC_CIO_S:
  2014.       printf("subb,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2015.       break;
  2016.     case ADD_CO_S:
  2017.       if (IMMEDIATE_P(s2))
  2018.     printf("addi,tr        %d,%s,%s",IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  2019.       else
  2020.     printf("add,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2021.       break;
  2022.     case ADC_CO_S:
  2023.       if (IMMEDIATE_P(s1))
  2024.     printf("subi,tr        %d,%s,%s",IMMEDIATE_VAL(s1),NAME(s2),NAME(d));
  2025.       else
  2026.     printf("sub,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2027.       break;
  2028.     case ADD_S:
  2029.       if (IMMEDIATE_P(s2))
  2030.     abort();
  2031.       else
  2032.     printf("addl,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2033.       break;
  2034.     case AND_S:
  2035.       if (IMMEDIATE_P(s2))
  2036.     printf("extru,tr    %s,31,%d,%s",NAME(s1),ffs_internal(IMMEDIATE_VAL(s2) + 1) - 1,NAME(d));
  2037.       else
  2038.     printf("and,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2039.       break;
  2040.     case IOR_S:
  2041.       printf("or,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2042.       break;
  2043.     case XOR_S:
  2044.       printf("xor,tr        %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2045.       break;
  2046.     case ANDC_S:
  2047.       printf("andcm,tr    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2048.       break;
  2049.     case SUB_S:
  2050.       printf("andcm,tr    %%r0,%s,%s",NAME(s2),NAME(d));
  2051.       break;
  2052.     case LSHIFTR_S:
  2053.       printf("extru,tr    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  2054.       break;
  2055.     case ASHIFTR_S:
  2056.       printf("extrs,tr    %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  2057.       break;
  2058.     case SHIFTL_S:
  2059.       printf("zdep,tr        %s,%d,%d,%s",NAME(s1),31-IMMEDIATE_VAL(s2),32-IMMEDIATE_VAL(s2),NAME(d));
  2060.       break;
  2061.     case ROTATEL_S:
  2062.       printf("shd,tr        %s,%s,%d,%s",NAME(s1),NAME(s1),32-IMMEDIATE_VAL(s2),NAME(d));
  2063.       break;
  2064.     case EXTS1_S:
  2065.       if (!IMMEDIATE_P(s2))
  2066.     abort();
  2067.       printf("extrs,tr    %s,%d,1,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  2068.       break;
  2069.     case EXTU1_S:
  2070.       if (!IMMEDIATE_P(s2))
  2071.     abort();
  2072.       printf("extru,tr    %s,%d,1,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  2073.       break;
  2074.     case EXTS2_S:
  2075.       if (!IMMEDIATE_P(s2))
  2076.     abort();
  2077.       printf("extrs,tr    %s,%d,2,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  2078.       break;
  2079.     case EXTU2_S:
  2080.       if (!IMMEDIATE_P(s2))
  2081.     abort();
  2082.       printf("extru,tr    %s,%d,2,%s",NAME(s1),31-IMMEDIATE_VAL(s2),NAME(d));
  2083.       break;
  2084.     case COPY_S:
  2085.       if (IMMEDIATE_P(s1))
  2086.     {
  2087.       if (IMMEDIATE_VAL(s1) + 0x400 < 0x800)
  2088.         printf("addi,tr        %d,%%r0,%s",IMMEDIATE_VAL(s1),NAME(d));
  2089.       else if (IMMEDIATE_VAL(s1) == 0x7fffffff)
  2090.         printf("zdepi,tr    -1,31,31,%s",NAME(d));
  2091.       else if (IMMEDIATE_VAL(s1) == 0x80000000)
  2092.         printf("zdepi,tr    1,0,1,%s",NAME(d));
  2093.       else
  2094.         abort();
  2095.     }
  2096.       else
  2097.     printf("addl,tr        %s,%%r0,%s",NAME(s1),NAME(d));
  2098.       break;
  2099. #elif SH
  2100.     case COPY:
  2101.       printf("mov    %s,%s",NAME(s1),NAME(d));break;
  2102.     case ADD:
  2103.       printf("add    %s,%s",NAME(s2),NAME(d));break;
  2104.     case ADD_CI:
  2105.       printf("movt    %s",NAME(d));break;
  2106.     case ADD_CIO:
  2107.       printf("addc    %s,%s",NAME(s2),NAME(d));break;
  2108.     case SUB:
  2109.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == 0)
  2110.     printf("neg    %s,%s",NAME(s2),NAME(d));
  2111.       else
  2112.     printf("sub    %s,%s",NAME(s2),NAME(d));
  2113.       break;
  2114.     case SUB_CIO:
  2115.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == 0)
  2116.     printf("negc    %s,%s",NAME(s2),NAME(d));
  2117.       else
  2118.     printf("subc    %s,%s",NAME(s2),NAME(d));
  2119.       break;
  2120.     case AND:
  2121.       if (IMMEDIATE_P(s2))
  2122.     {
  2123.       if (IMMEDIATE_VAL(s2) == 0xff)
  2124.         printf("extu.b    %s,%s",NAME(s1),NAME(d));
  2125.       else if (IMMEDIATE_VAL(s2) == 0xffff)
  2126.         printf("extu.w    %s,%s",NAME(s1),NAME(d));
  2127.       else
  2128.         printf("and    %s,%s    ! reallocate %s in r0",NAME(s2),NAME(d),NAME(d));
  2129.       break;
  2130.     }
  2131.       printf("and    %s,%s",NAME(s2),NAME(d));
  2132.       break;
  2133.     case IOR:
  2134.       if (IMMEDIATE_P(s2))
  2135.     {
  2136.       printf("or    %s,%s    ! reallocate %s in r0",NAME(s2),NAME(d),NAME(d));
  2137.       break;
  2138.     }
  2139.       printf("or    %s,%s",NAME(s2),NAME(d));break;
  2140.     case XOR:
  2141.       if (IMMEDIATE_P(s2))
  2142.     {
  2143.       printf("xor    %s,%s    ! reallocate %s in r0",NAME(s2),NAME(d),NAME(d));
  2144.       break;
  2145.     }
  2146.       printf("xor    %s,%s",NAME(s2),NAME(d));break;
  2147.     case SHIFTL_CO:
  2148.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2149.     printf("shll    %s",NAME(d));
  2150.       else abort();
  2151.       break;
  2152.     case SHIFTL:
  2153.       if (IMMEDIATE_P(s2)
  2154.       && (IMMEDIATE_VAL(s2) == 2 || IMMEDIATE_VAL(s2) == 8 || IMMEDIATE_VAL(s2) == 16))
  2155.     printf("shll%d    %s",IMMEDIATE_VAL(s2),NAME(d));
  2156.       else abort();
  2157.       break;
  2158.  
  2159.     case LSHIFTR_CO:
  2160.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2161.     printf("shlr    %s",NAME(d));
  2162.       else abort();
  2163.       break;
  2164.     case LSHIFTR:
  2165.       if (IMMEDIATE_P(s2)
  2166.       && (IMMEDIATE_VAL(s2) == 2 || IMMEDIATE_VAL(s2) == 8 || IMMEDIATE_VAL(s2) == 16))
  2167.     printf("shlr%d    %s",IMMEDIATE_VAL(s2),NAME(d));
  2168.       else abort();
  2169.       break;
  2170.  
  2171.     case ASHIFTR_CO:
  2172.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2173.     printf("shar    %s",NAME(d));
  2174.       else abort();
  2175.       break;
  2176.     case ROTATEL_CO:
  2177.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2178.     printf("rotl    %s",NAME(d));
  2179.       else abort();
  2180.       break;
  2181.     case ROTATEL:
  2182.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 16)
  2183.     printf("swap.w    %s,%s",NAME(s1),NAME(d));
  2184.       else abort();
  2185.       break;
  2186.     case MERGE16:
  2187.       printf("xtrct    %s,%s",NAME(s2),NAME(d));
  2188.       break;
  2189.     case ROTATEXL_CIO:
  2190.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2191.     printf("rotcl    %s",NAME(d));
  2192.       else abort();
  2193.       break;
  2194.     case ROTATER_CO:
  2195.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2196.     printf("rotr    %s",NAME(d));
  2197.       else abort();
  2198.       break;
  2199.     case ROTATEXR_CIO:
  2200.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 1)
  2201.     printf("rotcr    %s",NAME(d));
  2202.       else abort();
  2203.       break;
  2204.     case CYEQ:
  2205.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 0)
  2206.     printf("tst    %s,%s",NAME(s1),NAME(s1));
  2207.       else
  2208.     printf("cmp/eq    %s,%s",NAME(s2),NAME(s1));
  2209.       break;
  2210.     case CYGTS:
  2211.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 0)
  2212.     printf("cmp/pl    %s",NAME(s1));
  2213.       else
  2214.     printf("cmp/gt    %s,%s",NAME(s2),NAME(s1));
  2215.       break;
  2216.     case CYGES:
  2217.       if (IMMEDIATE_P(s2) && IMMEDIATE_VAL(s2) == 0)
  2218.     printf("cmp/pz    %s",NAME(s1));
  2219.       else
  2220.     printf("cmp/ge    %s,%s",NAME(s2),NAME(s1));
  2221.       break;
  2222.     case CYGTU:
  2223.       printf("cmp/hi    %s,%s",NAME(s2),NAME(s1));break;
  2224.     case CYGEU:
  2225.       printf("cmp/hs    %s,%s",NAME(s2),NAME(s1));break;
  2226.     case CYAND:
  2227.       if (IMMEDIATE_P(s2))
  2228.     printf("tst    %s,%s    ! reallocate %s in r0",NAME(s2),NAME(s1),NAME(s1));
  2229.       else
  2230.     printf("tst    %s,%s",NAME(s2),NAME(s1));
  2231.       break;
  2232.     case SETCY:
  2233.       printf("sett");break;
  2234.     case CLRCY:
  2235.       printf("clrt");break;
  2236.     case EXTS8:
  2237.       printf("exts.b    %s,%s",NAME(s1),NAME(d));break;
  2238.     case EXTS16:
  2239.       printf("exts.w    %s,%s",NAME(s1),NAME(d));break;
  2240.     case DECR_CYEQ:
  2241.       printf("dt    %s",NAME(d));break;
  2242. #elif I960
  2243.     case ADD:
  2244.       if (IMMEDIATE_P(s2) && (signed_word) IMMEDIATE_VAL(s2) < 0)
  2245.     printf("subo    %d,%s,%s",-IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  2246.       else
  2247.     printf("addo    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2248.       break;
  2249.     case SUB:
  2250.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) == -1)
  2251.     printf("not    %s,%s",NAME(s2),NAME(d));
  2252.       else
  2253.     printf("subo    %s,%s,%s",NAME(s2),NAME(s1),NAME(d));
  2254.       break;
  2255.     case COPY:
  2256.       if (IMMEDIATE_P(s1) && IMMEDIATE_VAL(s1) >= 32)
  2257.     {
  2258.       word x = IMMEDIATE_VAL(s1);
  2259.       if ((x & (x - 1)) == 0)
  2260.         {
  2261.           printf("setbit    %d,1,%s",floor_log2(x),NAME(d));
  2262.           break;
  2263.         }
  2264.       if (-x < 32)
  2265.         {
  2266.           printf("sub    %d,%s",-x,NAME(d));
  2267.           break;
  2268.         }
  2269.       abort();
  2270.     }
  2271.       printf("mov    %s,%s",NAME(s1),NAME(d));break;
  2272.     case AND:
  2273.       printf("and    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2274.     case IOR:
  2275.       printf("or    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2276.     case IORC:
  2277.       printf("notor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2278.     case XOR:
  2279.       printf("xor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2280.     case ANDC:
  2281.       printf("notand    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2282.     case EQV:
  2283.       printf("xnor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2284.     case NAND:
  2285.       printf("nand    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2286.     case NOR:
  2287.       printf("nor    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));break;
  2288.     case LSHIFTR:
  2289.       printf("shro    %s,%s,%s",NAME(s2),NAME(s1),NAME(d));break;
  2290.     case ASHIFTR:
  2291.       printf("shri    %s,%s,%s",NAME(s2),NAME(s1),NAME(d));break;
  2292.     case SHIFTL:
  2293.       printf("shlo    %s,%s,%s",NAME(s2),NAME(s1),NAME(d));break;
  2294.     case ROTATEL:
  2295.       printf("rotate    %s,%s,%s",NAME(s2),NAME(s1),NAME(d));break;
  2296.     case ADDC_960:
  2297.       if (IMMEDIATE_P(s2) && (signed_word) IMMEDIATE_VAL(s2) < 0)
  2298.     printf("subc    %d,%s,%s",-IMMEDIATE_VAL(s2),NAME(s1),NAME(d));
  2299.       else
  2300.     printf("addc    %s,%s,%s",NAME(s1),NAME(s2),NAME(d));
  2301.       break;
  2302.     case SUBC_960:
  2303.       printf("subc    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2304.     case SEL_NO_960:
  2305.       printf("selno    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2306.     case SEL_G_960:
  2307.       printf("selg    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2308.     case SEL_E_960:
  2309.       printf("sele    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2310.     case SEL_GE_960:
  2311.       printf("selge    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2312.     case SEL_L_960:
  2313.       printf("sell    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2314.     case SEL_NE_960:
  2315.       printf("selne    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2316.     case SEL_LE_960:
  2317.       printf("selle    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2318.     case SEL_O_960:
  2319.       printf("selo    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2320.     case CONCMPO_960:
  2321.       printf("concmpo    %s,%s",NAME(s1),NAME(s2)); break;
  2322.     case CONCMPI_960:
  2323.       printf("concmpi    %s,%s",NAME(s1),NAME(s2)); break;
  2324.     case CMPO_960:
  2325.       printf("cmpo    %s,%s",NAME(s1),NAME(s2)); break;
  2326.     case CMPI_960:
  2327.       printf("cmpi    %s,%s",NAME(s1),NAME(s2)); break;
  2328.     case SHIFTL_NT:
  2329.       printf("shlo    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2330.     case LSHIFTR_NT:
  2331.       printf("shro    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2332.     case ASHIFTR_NT:
  2333.       printf("shri    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2334.     case ADDO_NO_960:
  2335.       printf("addono    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2336.     case ADDO_G_960:
  2337.       printf("addog    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2338.     case ADDO_E_960:
  2339.       printf("addoe    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2340.     case ADDO_GE_960:
  2341.       printf("addoge    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2342.     case ADDO_L_960:
  2343.       printf("addol    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2344.     case ADDO_NE_960:
  2345.       printf("addone    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2346.     case ADDO_LE_960:
  2347.       printf("addole    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2348.     case ADDO_O_960:
  2349.       printf("addoo    %s,%s,%s",NAME(s1),NAME(s2),NAME(d)); break;
  2350.     case SUBO_NO_960:
  2351.       printf("subono    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2352.     case SUBO_G_960:
  2353.       printf("subog    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2354.     case SUBO_E_960:
  2355.       printf("suboe    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2356.     case SUBO_GE_960:
  2357.       printf("suboge    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2358.     case SUBO_L_960:
  2359.       printf("subol    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2360.     case SUBO_NE_960:
  2361.       printf("subone    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2362.     case SUBO_LE_960:
  2363.       printf("subole    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2364.     case SUBO_O_960:
  2365.       printf("suboo    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2366.     case ALTERBIT:
  2367.       printf("alterbit    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2368.     case SETBIT:
  2369.       printf("setbit    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2370.     case CLRBIT:
  2371.       printf("clrbit    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2372.     case CHKBIT:
  2373.       printf("chkbit    %s,%s",NAME(s2),NAME(s1)); break;
  2374.     case NOTBIT:
  2375.       printf("notbit    %s,%s,%s",NAME(s2),NAME(s1),NAME(d)); break;
  2376. #else
  2377. #error no assembly output code for this CPU
  2378. #endif
  2379.     default:abort();
  2380.     }
  2381.   printf("\n");
  2382. }
  2383.  
  2384. word tvalues[0x100];
  2385.  
  2386. /* TEST_SETS contains sets of input values and corresponding goal value used
  2387.    to test the correctness of a sequence.  N_TEST_SETS says how many sets
  2388.    are defined.  */
  2389. word *test_sets;
  2390. int n_test_sets;
  2391.  
  2392. word test_operands[] =
  2393. {
  2394.   -3, -2, -1, 0, 1, 2, 3, 30, 31, 32, 63, 64,
  2395.   VALUE_MIN_SIGNED,
  2396.   VALUE_MAX_SIGNED,
  2397.   VALUE_MIN_SIGNED + 1,
  2398.   VALUE_MAX_SIGNED - 1,
  2399. };
  2400. #define N_TEST_OPERANDS (sizeof(test_operands)/sizeof(test_operands[0]))
  2401.  
  2402. #ifndef N_RANDOM_TEST_OPERANDS
  2403. #define N_RANDOM_TEST_OPERANDS 25000
  2404. #endif
  2405.  
  2406. void
  2407. init_test_sets()
  2408. {
  2409.   unsigned int loop_vars[8];
  2410.   int pc, i, j;
  2411.   word *test_set;
  2412.   const int arity = goal_function_arity;
  2413.   word (*eval) (const word *) = eval_goal_function;
  2414.  
  2415.   if (sizeof (loop_vars) / sizeof (loop_vars[0]) <= arity)
  2416.     abort ();
  2417.  
  2418.   /* Allocate enough space in TEST_SETS for all combinations of TEST_OPERANDS
  2419.      and an additional N_RANDOM_TEST_OPERANDS random test sets.  */
  2420.   {
  2421.     static int n_words = 0;
  2422.  
  2423.     j = 1 + arity;
  2424.     for (i = arity - 1; i >= 0; i--)
  2425.       j *= N_TEST_OPERANDS;
  2426.  
  2427.     j += (1 + arity) * N_RANDOM_TEST_OPERANDS;
  2428.  
  2429.     if (n_words < j)
  2430.       {
  2431.     test_sets = (n_words == 0
  2432.              ? (word *) xmalloc (sizeof (word) * j)
  2433.              : (word *) xrealloc (test_sets, sizeof (word) * j));
  2434.     n_words = j;
  2435.       }
  2436.   }
  2437.  
  2438.   test_set = test_sets;
  2439.   j = 0;
  2440.  
  2441.   /* Start with all combinations of operands from TEST_OPERANDS.  */
  2442.   for (i = arity - 1; i >= 0; i--)
  2443.     loop_vars[i] = 0;
  2444.   for (;;)
  2445.     {
  2446.       for (i = arity - 1; i >= 0; i--)
  2447.     tvalues[i] = *test_set++ = test_operands[loop_vars[i]];
  2448.  
  2449.       /* Get the desired value for the current operand values.  */
  2450.       *test_set++ = (*eval)(tvalues);
  2451.       j++;
  2452.  
  2453.       /* General loop control.  This implements ARITY loops using induction
  2454.      variables in loop_vars[0] through loop_vars[ARITY - 1].  */
  2455.       i = 0;
  2456.       loop_vars[i] = (loop_vars[i] + 1) % N_TEST_OPERANDS;
  2457.       while (loop_vars[i] == 0)
  2458.     {
  2459.       i++;
  2460.       if (i >= arity)
  2461.         goto random;
  2462.       loop_vars[i] = (loop_vars[i] + 1) % N_TEST_OPERANDS;
  2463.     }
  2464.     }
  2465.  
  2466.   /* Now add the additional random test sets.  */
  2467.  random:
  2468.   for (i = N_RANDOM_TEST_OPERANDS - 1; i >= 0; i--)
  2469.     {
  2470.       for (pc = arity - 1; pc >= 0; pc--)
  2471.     tvalues[pc] = *test_set++ = random_word();
  2472.  
  2473.       *test_set++ = (*eval)(tvalues);
  2474.       j++;
  2475.     }
  2476.  
  2477.   n_test_sets = j;
  2478. }
  2479.  
  2480. void
  2481. print_operand (int op)
  2482. {
  2483.   if (IMMEDIATE_P(op))
  2484.     {
  2485.       if ((signed_word) IMMEDIATE_VAL(op) >= 10
  2486.       || (signed_word) IMMEDIATE_VAL(op) <= -10)
  2487.     {
  2488. #ifdef PSTR
  2489.       printf(PSTR, IMMEDIATE_VAL(op));
  2490. #else
  2491.       word x = IMMEDIATE_VAL(op);
  2492.       if (x >> 32 != 0)
  2493.         {
  2494.           printf("0x%x", (unsigned int) (x >> 32));
  2495.           printf("%08x", (unsigned int) x);
  2496.         }
  2497.       else
  2498.         printf("0x%x", (unsigned int) x);
  2499. #endif
  2500.     }
  2501.       else
  2502.     printf("%d", (int) IMMEDIATE_VAL(op));
  2503.     }
  2504.   else
  2505.     printf("r%u", op);
  2506. }
  2507.  
  2508. /* Test the correctness of a sequence in SEQUENCE[0] through
  2509.    SEQUENCE[N_INSNS - 1].  */
  2510.  
  2511. void
  2512. test_sequence(insn_t *sequence, int n_insns)
  2513. {
  2514.   int pc;
  2515.   int i, j;
  2516.   word *test_set = test_sets;
  2517.   const int arity = goal_function_arity;
  2518.  
  2519.   /* Test each of the precomputed values.  */
  2520.   for (j = n_test_sets; j > 0; j--)
  2521.     {
  2522.       /* Update the tvalues array in each iteration, as execution of the
  2523.      sequence might clobber the values.  (On 2-operand machines.)  */
  2524.       for (i = arity - 1; i >= 0; i--)
  2525.     tvalues[i] = *test_set++;
  2526.  
  2527.       /* Execute the synthesised sequence for the current operand
  2528.      values.  */
  2529. #if HAS_NULLIFICATION
  2530.       /* Kludge.  run_program returns -2 if a sequence depends on an
  2531.      undefined register.  */
  2532.       if (run_program (sequence, n_insns, tvalues, arity) == -2)
  2533.     return;
  2534. #else
  2535.       run_program (sequence, n_insns, tvalues);
  2536. #endif
  2537.       if (tvalues[sequence[n_insns - 1].d] != *test_set++)
  2538.     {
  2539.       /* Adaptively rearrange the order of the tests.  This set of test
  2540.          values is better than all that preceed it.  The optimal
  2541.          ordering changes with the search space.  */
  2542.       if ((j = n_test_sets - j) != 0)
  2543.         {
  2544.           int k = j >> 1;
  2545.           j *= (arity + 1);
  2546.           k *= (arity + 1);
  2547.           for (i = 0; i <= arity; i++)
  2548.         {
  2549.           word t = test_sets[j + i];
  2550.           test_sets[j + i] = test_sets[k + i];
  2551.           test_sets[k + i] = t;
  2552.         }
  2553.         }
  2554.       return;
  2555.     }
  2556.     }
  2557.  
  2558. #ifdef EXTRA_SEQUENCE_TESTS
  2559.   EXTRA_SEQUENCE_TESTS(sequence, n_insns);
  2560. #endif
  2561.  
  2562.   /* The tests passed.  Print the instruction sequence.  */
  2563.   if (success == 0 || flag_nl)
  2564.     printf("\n");
  2565.   success++;
  2566.  
  2567.   printf("%d:", success);
  2568.   for (pc = 0; pc < n_insns; pc++)
  2569.     {
  2570.       insn_t insn;
  2571.  
  2572.       insn = sequence[pc];
  2573.       if (flag_output_assembly)
  2574.     output_assembly(insn);
  2575.       else
  2576.     {
  2577.       /* Special case for insns that does not affect any general
  2578.          register.  */
  2579.       if (GET_INSN_CLASS (insn.opcode) == '='
  2580.           || GET_INSN_CLASS (insn.opcode) == '<')
  2581.         printf("\t%s(", GET_INSN_NAME(insn.opcode));
  2582.       else
  2583.         printf("\tr%u:=%s(", insn.d, GET_INSN_NAME(insn.opcode));
  2584.       print_operand (insn.s1);
  2585.  
  2586.       if (!UNARY_OPERATION(insn))
  2587.         {
  2588.           printf (",");
  2589.           print_operand (insn.s2);
  2590.         }
  2591.       printf(")\n");
  2592.     }
  2593.     }
  2594.   fflush(stdout);
  2595. }
  2596.  
  2597. #undef MAKENAME
  2598. #define MAKENAME(x)  x
  2599. #undef MAKE_LEAF
  2600. #define MAKE_LEAF 0
  2601.  
  2602. #define RECURSE(opcode, s1, s2, prune_hint) \
  2603.   recurse(opcode, n_values, s1, s2, v, 1, sequence, n_insns, values,    \
  2604.       n_values + 1, goal_value, allowed_cost, co, prune_hint)
  2605.  
  2606. /* Don't increment n_values unconditionally here, since we often reuse a
  2607.    register (if the insn can be nullified) and thus don't generate any more
  2608.    values.  Instead, increment n_values when we really use a new destination
  2609.    register.  */
  2610. #define PA_RECURSE(opcode, d, s1, s2, prune_hint, nullify_flag) \
  2611.   recurse(opcode, d, s1, s2, v, 1, sequence, n_insns, values,    \
  2612.       n_values + (n_values == d), goal_value, allowed_cost, co, prune_hint, nullify_flag)
  2613.  
  2614. /* CISC recurse, not generating a new register.  */
  2615. #define CRECURSE_2OP(opcode, d, s1, s2, cost, prune_hint) \
  2616.   recurse(opcode, d, s1, s2, v, cost, sequence, n_insns, values,    \
  2617.       n_values, goal_value, allowed_cost, co, prune_hint)
  2618.  
  2619. /* CISC recurse, generating a new register.  */
  2620. #define CRECURSE_NEW(opcode, d, s1, s2, cost, prune_hint) \
  2621.   recurse(opcode, d, s1, s2, v, cost, sequence, n_insns, values,    \
  2622.       n_values + 1, goal_value, allowed_cost, co, prune_hint)
  2623.  
  2624. #include "synth.def"
  2625.  
  2626. #undef MAKENAME
  2627. #define MAKENAME(x)  x##_last
  2628. #undef MAKE_LEAF
  2629. #define MAKE_LEAF 1
  2630. #undef RECURSE
  2631. #define RECURSE(opcode, s1, s2, prune_hint) \
  2632.   recurse_last(opcode, n_values, s1, s2, v, sequence, n_insns, goal_value)
  2633.  
  2634. /* Don't increment n_values unconditionally here, since we often reuse a
  2635.    register (if the insn can be nullified) and thus don't generate any more
  2636.    values.  Instead, increment n_values when we really use a new destination
  2637.    register.  */
  2638. #undef PA_RECURSE
  2639. #define PA_RECURSE(opcode, d, s1, s2, prune_hint, nullify_flag) \
  2640.   recurse_last(opcode, d, s1, s2, v, sequence, n_insns, goal_value)
  2641.  
  2642. /* CISC recurse, not generating a new register.  */
  2643. #undef CRECURSE_2OP
  2644. #define CRECURSE_2OP(opcode, d, s1, s2, cost, prune_hint) \
  2645.   recurse_last(opcode, d, s1, s2, v, sequence, n_insns, goal_value)
  2646.  
  2647. /* CISC recurse, generating a new register.  */
  2648. #undef CRECURSE_NEW
  2649. #define CRECURSE_NEW(opcode, d, s1, s2, cost, prune_hint) \
  2650.   recurse_last(opcode, d, s1, s2, v, sequence, n_insns, goal_value)
  2651.  
  2652. #if defined (DEBUG)
  2653. #include "synth2.def"
  2654. #else
  2655. #include "synth.def"
  2656. #endif
  2657.  
  2658.  
  2659. /* Call `synth' allowing deeper and deeper searches for each call.
  2660.    This way we achieve iterative deepening search.
  2661.  
  2662.    MAXMAX_COST is the maximum cost for any sequence we will accept.  */
  2663. void
  2664. main_synth(int maxmax_cost, int allowed_extra_cost)
  2665. {
  2666.   int max_cost;
  2667.   word values[0x100];
  2668.   insn_t sequence[0x100];
  2669.   int i, ii;
  2670.  
  2671.   init_immediates(tvalues);
  2672.   init_immediates(values);
  2673.   init_random_word();
  2674.   init_test_sets();
  2675.  
  2676.   /* Speed hack: Try to find random values that makes the goal function
  2677.      take a value != 0.  Many false sequences give 0 for all input,
  2678.      and this hack achieve quick rejection of these sequences.  */
  2679.   for (i = 0; i < 50; i++)
  2680.     {
  2681.       for (ii = 0; ii < goal_function_arity; ii++)
  2682.     values[ii] = random_word();
  2683.       if ((*eval_goal_function)(values) != 0)
  2684.     break;
  2685.     }
  2686.  
  2687.   ii = 0;
  2688. #if KNOW_START
  2689.   switch (goal_function)
  2690.     {
  2691.     case FFS:
  2692. #if M88000
  2693.       /* Best ffs starting place.  */
  2694.       sequence[ii++] = (insn_t) { ADC_CO, CNST(0), 0, 1 };
  2695.       sequence[ii++] = (insn_t) { AND, 0, 1, 2 };
  2696. #endif
  2697.       break;
  2698.  
  2699.     case ZDEPI_FOR_MOVSI:
  2700. #if SPARC
  2701.       sequence[ii++] = (insn_t) { SUB, CNST(0), 0, 1 };
  2702.       sequence[ii++] = (insn_t) { AND, 0, 1, 2 };
  2703. #endif
  2704.       break;
  2705.     default: break;
  2706.     }
  2707. #endif
  2708.  
  2709.   printf("Superoptimizing at cost");
  2710.   success = 0;
  2711.   for (max_cost = 1; max_cost <= maxmax_cost; max_cost++)
  2712.     {
  2713. #if TIMING
  2714.       for (i = 0; i <= max_cost; i++)
  2715.     timings[i] = 0;
  2716. #endif
  2717.  
  2718.       if (success)
  2719.     printf ("[cost %d]\n", max_cost + ii);
  2720.       else
  2721.     printf(" %d", max_cost + ii);
  2722.       fflush(stdout);
  2723.  
  2724. #if HAS_NULLIFICATION
  2725.       i = run_program (sequence, ii, values, goal_function_arity);
  2726. #else
  2727.       i = run_program (sequence, ii, values);
  2728. #endif
  2729.  
  2730.       /* Don't pass CY_JUST_SET ever, since we don't know which of the
  2731.      predefined insn above set cy.  */
  2732.       SYNTH(sequence, ii, values, goal_function_arity+ii,
  2733.         (*eval_goal_function)(values),
  2734.         max_cost, i, NO_PRUNE
  2735.         , NOT_NULLIFY
  2736.         );
  2737.  
  2738. #ifdef STATISTICS
  2739.       printf("\n");
  2740.       printf("heuristic accept count:%u\n", heuristic_accept_count);
  2741.       printf("heuristic reject count:%u\n", heuristic_reject_count);
  2742. #endif
  2743. #if TIMING
  2744.       for (i = 1; i <= max_cost; i++)
  2745.     printf ("time %d: %d\n", i, timings[i] - timings[i - 1]);
  2746. #endif
  2747.  
  2748.       if (success)
  2749.     {
  2750.       allowed_extra_cost--;
  2751.       if (allowed_extra_cost < 0)
  2752.         {
  2753.           static char *s[] = {"", "s"};
  2754.           printf("[%d sequence%s found]\n", success,
  2755.               s[success != 1]);
  2756.           return;
  2757.         }
  2758.     }
  2759.     }
  2760.   printf(" failure.\n");
  2761. }
  2762.  
  2763. /* Create a function for each DEF_GOAL.  When optimized, these are very
  2764.    efficient.  */
  2765. #undef    DEF_GOAL
  2766. #ifdef __STDC__
  2767. #define DEF_GOAL(SYM,ARITY,NAME,CODE)         \
  2768. word SYM ## _func (const word *v)        \
  2769. GOAL_FUNCTION (ARITY, CODE)
  2770. #else
  2771. #define DEF_GOAL(SYM,ARITY,NAME,CODE)         \
  2772. word SYM/**/_func (v) word *v;            \
  2773. GOAL_FUNCTION (ARITY, CODE)
  2774. #endif
  2775. #define GOAL_FUNCTION(ARITY,CODE)        \
  2776. {                        \
  2777.   word r, v0, v1, v2, v3;            \
  2778.   switch (ARITY)                \
  2779.     {                        \
  2780.     default:                    \
  2781.       abort ();                    \
  2782.     case 4: v3 = v[3];                \
  2783.     case 3: v2 = v[2];                \
  2784.     case 2: v1 = v[1];                \
  2785.     case 1: v0 = v[0];                \
  2786.     }                        \
  2787.   CODE;                        \
  2788.   return r;                    \
  2789. }
  2790. #undef    DEF_SYNONYM
  2791. #define DEF_SYNONYM(SYM,NAME)
  2792. #include "goal.def"
  2793.  
  2794. struct
  2795. {
  2796.   char *fname;
  2797.   enum goal_func fcode;
  2798.   int arity;
  2799.   char *c_code;
  2800.   word (*function)(const word*);
  2801. } goal_table[] =
  2802. {
  2803. /* Start off with entries so that goal_names[i].fcode == i.  */
  2804. #undef    DEF_GOAL
  2805. #ifdef __STDC__
  2806. #define DEF_GOAL(SYM,ARITY,NAME,CODE) {NAME, SYM, ARITY, #CODE, SYM ## _func},
  2807. #else
  2808. #define DEF_GOAL(SYM,ARITY,NAME,CODE) {NAME, SYM, ARITY, "CODE", SYM/**/_func},
  2809. #endif
  2810. #undef    DEF_SYNONYM
  2811. #define DEF_SYNONYM(SYM,NAME)
  2812. #include "goal.def"
  2813.  
  2814. /* Now add the synonyms.  */
  2815. #undef    DEF_GOAL
  2816. #define DEF_GOAL(SYM,ARITY,NAME,CODE)
  2817. #undef    DEF_SYNONYM
  2818. #define DEF_SYNONYM(SYM,NAME) {NAME, SYM, 0, 0},
  2819. #include "goal.def"
  2820. };
  2821.  
  2822. #define GET_GOAL_NAME(X) (goal_table[X].fname)
  2823. #define GET_GOAL_ARITY(X) (goal_table[X].arity)
  2824. #define GET_GOAL_C_CODE(X) (goal_table[X].c_code)
  2825. #define GET_GOAL_FUNCTION(X) (goal_table[X].function)
  2826.  
  2827. #ifdef HAVE_RINDEX
  2828. #define strrchr rindex
  2829. #endif
  2830.  
  2831. extern char *strrchr();
  2832.  
  2833. int
  2834. main(int argc, char **argv)
  2835. {
  2836.   int maxmax_cost = 4;
  2837.   int allowed_extra_cost = 0;
  2838.   int flag_all = 0;
  2839.   char *program = strrchr (argv[0], '/');
  2840.  
  2841.   if (!program)
  2842.     program = argv[0];
  2843.   else
  2844.     program++;
  2845.  
  2846.   goal_function = LAST_AND_UNUSED_GOAL_CODE;
  2847.  
  2848.   argv++;
  2849.   argc--;
  2850.  
  2851.   while (argc > 0)
  2852.     {
  2853.       char *arg = argv[0];
  2854.       int arglen = strlen(arg);
  2855.  
  2856.       if (arglen < 2)
  2857.     arglen = 2;
  2858.  
  2859.       if (!strncmp(arg, "-version", arglen))
  2860.     {
  2861.       printf ("%s version %s\n", program, version_string);
  2862.       printf ("(%s)\n", TARGET_STRING);
  2863.       if (argc == 1)
  2864.         exit (0);
  2865.     }
  2866.       else if (!strncmp(arg, "-assembly", arglen))
  2867.     flag_output_assembly = 1;
  2868.       else if (!strncmp(arg, "-no-carry-insns", arglen))
  2869.     flag_use_carry = 0;
  2870.       else if (!strncmp(arg, "-all", arglen))
  2871.     flag_all = 1;
  2872.       else if (!strncmp(arg, "-nl", arglen))
  2873.     flag_nl = 1;
  2874.       else if (!strncmp(arg, "-shifts", arglen))
  2875.     flag_shifts = 1;
  2876.       else if (!strncmp(arg, "-extracts", arglen))
  2877.     flag_extracts = 1;
  2878.       else if (!strncmp(arg, "-max-cost", arglen))
  2879.     {
  2880.       argv++;
  2881.       argc--;
  2882.       if (argc == 0)
  2883.         {
  2884.           fprintf(stderr, "superoptimizer: argument to `-max-cost' expected\n");
  2885.           exit(-1);
  2886.         }
  2887.       maxmax_cost = atoi(argv[0]);
  2888.     }
  2889.       else if (!strncmp(arg, "-extra-cost", arglen))
  2890.     {
  2891.       argv++;
  2892.       argc--;
  2893.       if (argc == 0)
  2894.         {
  2895.           fprintf(stderr, "superoptimizer: argument `-extra-cost' expected\n");
  2896.           exit(-1);
  2897.         }
  2898.       allowed_extra_cost = atoi(argv[0]);
  2899.     }
  2900.       else if (!strncmp(arg, "-f", 2))
  2901.     {
  2902.       int i;
  2903.       for (i = 0; i < sizeof(goal_table) / sizeof(goal_table[0]); i++)
  2904.         {
  2905.           if (!strcmp(arg + 2, goal_table[i].fname))
  2906.         {
  2907.           goal_function = goal_table[i].fcode;
  2908.           goal_function_arity = GET_GOAL_ARITY(goal_function);
  2909.           eval_goal_function = GET_GOAL_FUNCTION(goal_function);
  2910.           break;
  2911.         }
  2912.         }
  2913.       if (goal_function == LAST_AND_UNUSED_GOAL_CODE)
  2914.         {
  2915.           fprintf(stderr, "superoptimizer: unknown goal function\n");
  2916.           exit(-1);
  2917.         }
  2918.     }
  2919.       else
  2920.     {
  2921.       int i, len, maxlen, cols, maxcols;
  2922.       char *prefix;
  2923.       fprintf(stderr, "Calling sequence:\n\n");
  2924.       fprintf(stderr, "\t%s -f<goal-function> [-assembly] [-max-cost n] \\\n", program);
  2925.       fprintf(stderr, "\t\t[-no-carry-insns] [-extra-cost n] [-nl]\n\n");
  2926.       fprintf(stderr, "Target machine: %s\n\n", TARGET_STRING);
  2927.       fprintf(stderr, "Supported goal functions:\n\n");
  2928.  
  2929.       maxlen = 0;
  2930.       for (i = 0; i < sizeof(goal_table) / sizeof(goal_table[0]); i++)
  2931.         {
  2932.           len = strlen (goal_table[i].fname);
  2933.           if (len > maxlen)
  2934.         maxlen = len;
  2935.         }
  2936.  
  2937.       maxcols = 79 / (maxlen + 2);
  2938.       if (maxcols < 1)
  2939.         maxcols = 1;
  2940.  
  2941.       cols = 1;
  2942.       prefix = "";
  2943.       for (i = 0; i < sizeof(goal_table) / sizeof(goal_table[0]); i++)
  2944.         {
  2945.           fprintf(stderr, "%s  %-*s", prefix, maxlen, goal_table[i].fname);
  2946.  
  2947.           cols++;
  2948.           if (cols > maxcols)
  2949.         {
  2950.           cols = 1;
  2951.           prefix = "\n";
  2952.         }
  2953.           else
  2954.         prefix = "";
  2955.         }
  2956.  
  2957.       fprintf(stderr, "\n");
  2958.       exit(-1);
  2959.     }
  2960.  
  2961.       argv++;
  2962.       argc--;
  2963.     }
  2964.  
  2965.   if (flag_all)
  2966.     {
  2967.       for (goal_function = 0; goal_function < LAST_AND_UNUSED_GOAL_CODE;
  2968.        goal_function++)
  2969.     {
  2970.       printf("Searching for goal %s: ",
  2971.           GET_GOAL_NAME (goal_function));
  2972.       printf("%s\n", GET_GOAL_C_CODE(goal_function));
  2973.  
  2974.       goal_function_arity = GET_GOAL_ARITY(goal_function);
  2975.       eval_goal_function = GET_GOAL_FUNCTION(goal_function);
  2976.       main_synth(maxmax_cost, allowed_extra_cost);
  2977.     }
  2978.       exit (0);
  2979.     }
  2980.  
  2981.   if (goal_function == LAST_AND_UNUSED_GOAL_CODE)
  2982.     {
  2983.       fprintf(stderr, "superoptimizer: missing goal function definition\n");
  2984.       exit(-1);
  2985.     }
  2986.  
  2987.   printf("Searching for %s\n", GET_GOAL_C_CODE(goal_function));
  2988.   main_synth(maxmax_cost, allowed_extra_cost);
  2989.   exit (!success);
  2990. }
  2991.  
  2992. /* Aux stuff that should go into a separate file.  */
  2993.  
  2994. int
  2995. ffs_internal(x)
  2996.      word x;
  2997. {
  2998.   int co, ci = -1;
  2999.   word d;
  3000.   PERFORM_FFS(d, co, x, ci);
  3001.   return d;
  3002. }
  3003.  
  3004. int
  3005. floor_log2 (x)
  3006.      word x;
  3007. {
  3008.   register int log = -1;
  3009.   while (x != 0)
  3010.     log++,
  3011.     x >>= 1;
  3012.   return log;
  3013. }
  3014.  
  3015. int
  3016. ceil_log2 (x)
  3017.      word x;
  3018. {
  3019.   return floor_log2 (x - 1) + 1;
  3020. }
  3021.  
  3022. const char clz_tab[] =
  3023. {
  3024.   32,31,30,30,29,29,29,29,28,28,28,28,28,28,28,28,
  3025.   27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,
  3026.   26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
  3027.   26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
  3028.   25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
  3029.   25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
  3030.   25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
  3031.   25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
  3032.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3033.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3034.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3035.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3036.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3037.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3038.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3039.   24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
  3040. };
  3041.  
  3042. const char ctz_tab[] =
  3043. {
  3044.   8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3045.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3046.   5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3047.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3048.   6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3049.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3050.   5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3051.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3052.   7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3053.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3054.   5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3055.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3056.   6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3057.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3058.   5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3059.   4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
  3060. };
  3061.  
  3062. const char ff1_tab[] =
  3063. {
  3064.   32,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
  3065.   4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
  3066.   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
  3067.   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
  3068.   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  3069.   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  3070.   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  3071.   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  3072.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3073.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3074.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3075.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3076.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3077.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3078.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3079.   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3080. };
  3081.